Prog or Obj PHP PDF

PROGRAMACIÓN ORIENTADA A OBJETOS EN PHP
Programa: ANÁLISIS Y DESARROLLO DE SISTEMAS DE

INFORMACIÓN
Duración estimada de estudio (horas): 6 horas
Estructura de contenidos
Mapa conceptual............................................................................2
Introducción..................................................................................3
1. Definiendo las Clases..................................................................4
1.1. Estructura general de una clase.................................................5
1.2. Los Atributos...........................................................................6
1.3. Los Constructores....................................................................7
1.4. Los Métodos............................................................................8
1.5. La Encapsulación.....................................................................9
1.6. Modificadores de Acceso.........................................................11
2. Representación de las Relaciones entre Clases.............................. 12
2.1. Relación de Dependencia........................................................12
2.2. Relación de Agregación...........................................................13
2.3. Relación de Composición.........................................................14
3. Los Objetos..............................................................................14
3.1. Ejemplo de construcción de objetos.......................................... 15
3.2. Herencia...............................................................................16
3.3. Ejecución de Métodos.............................................................19
4. Ejercicio de ejemplo completo....................................................19
Recursos bibliográficos...................................................................30
Glosario......................................................................................31
FAVA - Formación en Ambientes Virtuales de Aprendizaje SENA - Servicio Nacional de Aprendizaje

Programación Orientada a Objetos en PHP
Programación Orientada a Objetos en PHP.

Mapa Conceptual
2
Introducción
Al revisar los conceptos relacionados con la construcción de sistemas de

información es relevante explorar, reconocer y desarrollar competencias
en el uso de la Programación Orientada a Objetos (POO). La aplicación
de recursos y elementos como: Clase, Objeto, Herencia, Polimorfismo,
Abstracción y Encapsulación son parte esencial de la POO.
El presente objeto de aprendizaje, presenta los conceptos y recursos que

le permitan comprender los fundamentos de la Programación Orientada a
Objetos utilizando el lenguaje de desarrollo PHP.
3
1. Definición de una clase en PHP
Una clase inicia con la palabra reservada class en minúscula y después el

nombre.
class NombreClase
{
Declaración de Clases Abstractas
Las clases abstractas son aquellas que no necesitan ser instanciadas, pero
si pueden ser heredadas. Se definen anteponiendo la palabra abstract.
<¿php
abstract class NombreClase{
//No necesita ser instanciada
?>
4
Declaración de Clases Final
PHP incorpora clases finales que no pueden ser heredadas por otra. Se
definen anteponiendo la palabra reservada final.
<¿php
final class NombreClase{
//esta clase no puede ser heredada
?>
1.1 Estructura General de una Clase en PHP.
La siguiente figura presenta la estructura general de una clase, la definición

de los atributos, seguido del constructor, como elemento opcional el
destructor y por último la definición de los métodos de la clase.
1 <¿php
2
3 class NombreClase
4 {
5
6 //Definición de Atributos
7
8 //Definición Constructor
9
10 //Definición de destructor (opcional)
11
12 //Definición de Métodos
13
14 }
15 ?>
16
5
Ahora vamos a mostrar la implementación de una clase denominada

Persona como ejemplo.
1 <¿php
2 class Persona
3 {
5 private $nombre;
6
7 //Constructor
8 public function Persona($nombre)
9 {
10 $this->nombre=$nombre;
11 }
12
14 public function getNombre()
15 {
16 return $this->nombre;
17 }
18 public function setNombre($value)
19 {
20 $this->nombre=$value;
21 }
22
23 public function leer($libro)
24 {
25 //aquí va el código del método
26 }
27 }
28 ?>
1.2 Los Atributos
Los atributos son las características, cualidades, propiedades distintivas

de cada clase. Contienen información sobre el objeto. Determinan la
apariencia, estado y demás particularidades de la clase. Varios objetos de
una misma clase tendrán los mismos atributos pero con valores diferentes.
Cuando creamos un objeto de una clase determinada, los atributos

declarados por la clase son localizadas en memoria y pueden ser
modificados mediante los métodos.
6
Lo más conveniente es que los atributos sean privados para que solo los
métodos de la clase puedan modificarlos.
Definición:
//Definición de Atributos
private $identificación;
private $nombre;
private $fechanacimiento;
1.3 Los constructores
El constructor es un método especial de una clase. El objetivo fundamental

del constructor es inicializar los atributos del objeto que creamos.
Se pueden definir varios constructores (sobrecarga de constructores),

que permitan crear el objeto de diferentes maneras.
Definición:
Se pueden definir de dos formas:
1. Mediante un método llamado __construct
//Constructor
public function __construct($nombre)
{
$this->nombre=$nombre;
}
7
2. Mediante un método llamado igual que el nombre de la clase.
//Constructor
public function Persona($nombre)
{
}
Otras características de los constructores son:
• El constructor se ejecuta inmediatamente luego de crear un objeto y

no puede ser llamado nuevamente.
• Un constructor no puede retornar dato.
• Un constructor puede recibir parámetros que se utilizan normalmente

para inicializar atributos.
• El constructor es un método opcional, de todos modos es muy común

definirlo.
1.4 Los Métodos
Los métodos son como las funciones en los lenguajes estructurados, pero
están definidos dentro de una clase y operan sobre los atributos de dicha
clase.
Los métodos de una Clase son los que nos permiten definir las
funcionalidades o responsabilidades de la clase. Para ello debemos
preguntarnos que puede hacer la clase.
El objetivo de un método es ejecutar las actividades que tiene encomendada

la clase a la cual pertenece.
8
Los atributos de un objeto se modifican mediante llamadas a sus métodos.
Ejemplo Definición de Métodos
//Definición de Métodos
public function getNombre()
{
return $this->nombre;
}
public function setNombre($value)

{
$this->nombre=$value;
}
En los ejemplos anteriores el primer método retorna un valor para ello se

utiliza la sentencia:
return $variable;
El segundo Método recibe un parámetro y este parámetro es asignado al
atributo nombre.
$this->nombre=$value;
1.5 Encapsulación
La encapsulación en un programa se da cuando se definen los atributos

de una clase con el nivel de acceso más restrictivo, para que el acceso o
la modificación de los atributos de esa clase sólo sean posibles a través
de sus métodos
9
1 <¿php
2 class Persona
3 {
5 private $identificación;
6 private $nombre; Encapsulación
7 private $fechanacimiento;
8
9 //Constructor
10 public function Persona($nombre)
11 {
13 }
14
17 {
19 }
20 public function setNombre($value)
21 {
23 }
24
25 public function getIdentificación()
26 { Métodos
27 return $this->identificación;
28 }
29 public function setidentificación($value)
30 {
32 }
33
34 public function getFechaNacimiento()
35 {
36 return $this->fechaNacimiento;
37 }
38 public function setFechaNacimiento($value)
39 {
40 $this->fechaNacimiento=$value;
41 }
42 }
43 ?>
10
1.6 Modificadores de Acceso
Public: Cuándo un atributo o un método es definido como public se puede

acceder a él directamente desde donde se haya instanciado el objeto.
Ejemplos:
public $atributo;
public function metodo()

{
return $valor;
}
Private: Cuando un atributo o un método es definido como private, solo

se puede acceder a ellos desde la misma clase.
Ejemplos:
private $identificación;
private $nombre;
private $fechanacimiento;
//Constructor
private function operacion($valor1)
{
return $valor*2;
}
Protected: Cuando un atributo o método es definido como protected,

solo se puede acceder a él sin ninguna restricción desde la clase o desde
sus heredados.
Ejemplos:
protected $identificación;
protected $nombre;
11
2. Representación de las Relaciones entre Clases
2.1 Relación de Dependencia
Es una relación de uso entre dos entidades, una de las clases usa a la
otra.
La relación de dependencia es cuando una clase depende de la funcionalidad

que ofrece otra clase
class Class Model
Motor
Carro
- cilindraje
+ mostrarMotor(Motor):void
+ getCilindraje() : var
+ Motor(var) : void
Ahora como se traduce en código PHP:
1 <¿php
2 require_once ('Motor.php');
3
4 class Carro
5 {
6
7 function mostrarMotor(Motor $objetoMotor)
8 {
9 echo $objetoMotor->getCilindraje();
10 }
11
12 }
13 ?>
14
12
2.2 Relación de Agregación
Es una relación de asociación donde una de las clases forma parte del
todo correspondiente a la otra clase.
Curso Aprendices
- aprendices: array
+ mostrarMotor(Motor):void
Ahora como se traduce en PHP:
1 <?php
2 require_once ('Aprendices.php');
3 class Curso
4 {
5 //definiendo un arreglo donde se van a guardar los aprendices
6 private $aprendices = array();
7
8 function agregarAprendices(Aprendices $aprendiz)
9 {
10 //se agrega al arreglo $aprendices el objeto aprendiz
11 $this->aprendices[] = $aprendiz;
12 }
13 }
14
15 $objCurso = new Curso();
16 $objCurso->agregarAprendices(new Aprendices());
21 /*Como ejemplo en el curso anterior solo se agregaron
22 5 aprendices */
23 ?>
13
2.3 Relación de Composición
Similar a la relación de agregación solo que en está relación existe una

relación de vida.
Por ejemplo:
Empresa Empleado
En esta relación la empresa existe si tiene empleados. El código en PHP

no cambia en nada frente a la relación de agregación.
3 Los objetos
Para crear un objeto, es necesario emplear alguno de los constructores de

la clase. Cuando se esta creando un objeto se esta instanciando la clase.
Desde un archivo php podemos tener el siguiente código para crear un

objeto:
$objeto = new Clase();
$objeto = new Clase($parametros);
En la creación del objeto encontramos la sentencia new y después va el

nombre de la clase. Recordemos que al momento de instanciar se llama
automáticamente a los constructores que tenga la clase. Por lo tanto
podemos crear un objeto de diferentes formas, dependiendo del número
de constructores.
14
3.1 Ejemplo de construcción de objetos
El ejemplo planteado permite crear una página php que instancia dos
objetos de la clase persona y muestra el nombre de cada uno de ellos.
En la siguiente imagen se relaciona el ejemplo completo:
1 <¿php
2 //incluimos el archivo donde esta el código de la clase Persona
3 include “Persona.php”;
4
5 //Instanciamos el primer Objeto
6 $objPersona=new Persona(“Pedro Picapiedra”);//instanciamos
7
8 /* Para poder mostrar en pantalla el nombre de la persona debemos utilizar el
9 método gerNombre(), ya que el atributo $nombre es privado.*/
10
11
12 //Ahora Instanciamos otra vez la clase persona
13 $objPersona=new Persona(“Vilma”);
14 echo “ Nombre del segundo obeto Persona : ”. $objPersona->getNombre();
15 ?>
Explicación línea por línea.
<?php Código de inicio del código php.
Include La forma como incluimos un archivo php, aquí estamos

“Persona.php” incluyendo el archivo Persona.php que contiene el código
de la clase persona.
$objPersona = Esta línea crea un objeto llamado $objPersona y estamos

new pasando como parámetro el valor de Pedro Picapiedra.
Persona(“Pedro Veamos la relación con la clase
Picapiedra”)
//Constructor
public function Persona($nombre)
{
}
$objPersona=new Persona(”Pedro Picapiedra”); //instanciamos
15
echo “ Esta línea obtiene el nombre de la persona mediante el
Nombre del Primer
obeto Persona : método getNombre() de la clase persona y lo imprime en
$objPersona=new Persona(”Pedro Picapiedra”); //instanciamos
echo “ Esta línea obtiene el nombre de la persona mediante el

Nombre del Primer
obeto Persona : método getNombre() de la clase persona y lo imprime en
”.$objPersona->ge
tNombre(); pantalla. Se debe utilizar ese método debido a que el
atributo nombre está definido como private.
Veamos la relación
//Definición de Métodos
public function getNombre()
{
return $this->nombre;
}
echo “ Nombre del Primer objeto Persona :”

.$objPersona->getNombre();
¿> Etiqueta de cierre del código php
El resultado final al ejecutar el código es el siguiente:
localhost
localhost/virtualidad/
Nombre del primer Objeto Persona : Pedro Picapiedra

Nombre del segundo Objeto Persona : Vilma
3.2 Herencia:
La herencia es la que me permite crear nuevas clases partiendo de clases

ya existentes. En la Herencia existe el concepto de SuperClase o Clase
padre y la clase que hereda se le conoce como clase Hija.
16
Definición de una clase que hereda de otra
Ejemplo:
class Hija extends Padre

{
Como ejercicio vamos a crear una clase Estudiante que hereda de la Clase
persona.
protected $nombre;
Para ello primero vamos a modificar la clase Persona y vamos a declarar

el atributo nombre como protected.
1 <¿php
2 include “Persona.php”; //la incluimos para poder acceder a ella
3 class Estudiante extends Persona
4 {
5 //Atributo curso: Que curso estudia el Estudiante.
6 private $curso;
7
8 //Método que obtiene el curso que estudia el estudiante.
9 public function getCurso()
10 {
11 return $this->curso;
12 }
13
14 //Método que permite cambiar el curso del estudiante.
15 public function setCurso($value)
16 {
17 $this->curso=$value;
18 }
19
20 //Constructor Clase Estudiante
21 public function Estudiante($nombre, $curso)
22 {
23 /* como iniciamos el atributo nombre que lo hereda de la
24 clase Persona para ello el atributo nombre debe ser declarado
25 como protected.*/
27 $this->curso=$curso;
28 }
29 }
30 ?>
31
17
Ahora vamos a crear un archivo donde podamos crear un objeto

estudiante.
<?php
//incluimos el archivo donde está el código de la clase Persona
include “Estudiante.php”;
//Instanciamos para crear el primer objeto tipo Estudiante
Estudiante($nombre, $curso)
$objEstudiante=new Estudiante(
En la imagen anterior podemos ver en el momento de codificar los

parámetros necesarios solicitados por el constructor de la clase Estudiante.
Por lo anterior debemos de ingresar el nombre del Estudiante y el Curso.
Código completo de la Implementación.
1 <html>
<meta http-equiv="Contect-Type" contect="text/html; charset=utf-8">
2 <?php
3
4 //incluimos el archivo donde está el código de la clase Persona
5 include "Estudiante.php";
//Instanciamos para crear el primer objeto tipo Estudiante
6
7 $objEstudiante=new Estudiante("César Cuéllar", "DASI");
8
//creamos otro objeto de tipo Estudiante
9 $objEstudiante=new Estudiante("Marcela Médez", "Multimedia");
10
11 echo “ESTUDIANTES INSCRITOS ”;
12
/*Vamos ahora a imprimir en pantalla los Datos de los Estudiantes
13 accedemos al método getNombre() que lo hereda de la clase persona*/
14
15 echo “ Nombre del Estudiante : ”. $objEstudiante->getNombre();
16 /*Ahora vamos a imprimir en pantalla el Curso, para ello
17 accedemos al método getCurso() propio de la clase Estudiante.*/
18 echo “ Curso que se encuentra realizando el Estudiante : ”. $objEstudiante->getNombre();
19
echo “ Nombre del Estudiante : ”. $objEstudiante2->getNombre();
20 echo “ Curso que se encuentra realizando el Estudiante : ”. $objEstudiante2->getNombre();
21
22 ?>
18
Resultado de la Implementación
localhost
localhost/virtualidad/crearEstudiante.php
ESTUDIANTES INSCRITOS
Nombre del Estudiante: César Cuéllar

Curso que se encuentra realizando el Estudiante: ADSI
Nombre del Estudiante: Marcela Méndez
Curso que se encuentra realizando el Estudiante: Multimedia
3.3 Ejecución de Métodos
Después de que se ha creado un objeto se puede acceder a los métodos

públicos de la clase.
$objEstudiante=new Estudiante("César Cuéllar", "DASI");
$objEstudiante->
getCurso() Estudiante Estudiante.php
getNombre() Persona Persona.php
Métodos leer($libro) Persona Persona.php
setCurso($value) Estudiante Estudiante.php
setNombre($value) Persona Persona.php
Nos muestra los métodos públicos propios de la clase o nos muestra los
métodos heredados de alguna clase que sean declarados como protected.
4 Ejercicio de ejemplo completo
Enunciado
Se requiere hacer una aplicación que permita calcular el salario a pagar a

los empleados de una empresa. En la empresa hay dos tipos de empleados
unos contratistas y otros de planta.
19
A los contratitas el salario depende del valor de la hora.
Formula: Salario = ValorHora * TotalHoras
El salario de los de planta depende del sueldo básico mensual.
Formula = SalarioBasico + HorasExtras – deducciones.
Diagrama de Clases
class Class Model

Empleado
# cilindraje: string
# identificacion: int
# nombre: string
# salario: float
+ Empleado(var, var, var) : void

« property get »
+ getcargo() : var
+ getidentificacion() : var
+ getnombre() : var
+ getsalario() : var
« property get »
+ setcargo(var) : void
+ setidentificacion(var) : void
+ seinombre(var) : void
+ setsalario(var) : void
Contratista Planta
- totalHoras: int - deducciones: float

- valorHora: float - sueldoBasico: float
- valorExtras: float
+ calcularSalario(var, var)
+ Contratista() : void + calcularSalario()
+ Planta() : void
« property get »
+ getcargo() : var « property get »
+ getidentificacion() : var + getcargo() : var
+ getnombre() : var + getdeducciones() : var
+ getsalario() : var + getidentificacion() : var
+ gettotalHoras() : var + getnombre() : var
+ getvalorHoras() : var + getsalario() : var
+ getsueldoBasico() : var
« property get »
+ getvalorExtras() : var
+ settotal(var) : void
+ setvalorHoras(var) : void « property get »
+ setdeducciones(var) : void
+ setsueldoBasico(var) : void
+ setvalorExtras(var) : void
20
Código Clase Empleado
1 <¿php
2 /**
3 * @author César Cuéllar
4 * @version 1.0
5 * @created 20-oct-2013 07:47:27 a.m.
6 */
7 class Empleado
8 {
9 protected $cargo;
10 protected $identificacion;
11 protected $nombre;
12 protected $salario;
13
14 //Constructor
15 /**
16 * @param cargo, @param salario, @param nombre, @param
17 identificacion
18 */
19 public function Empleado($identificacion,$nombre,$cargo)
20 {
21 $this->identificacion=$identificacion;
23 $this->cargo=$cargo;
24 }
25
26 protected function getCargo()
27 {
28 return $this->cargo;
29 }
30
31 protected function getIdentificacion()
32 {
33 return $this->identificacion;
34 }
35
36 protected function getNombre()
37 {
39 }
40
41 protected function getSalario()
42 {
43 return $this->salario;
21 44 }
45 FAVA - Formación en Ambientes Virtuales de Aprendizaje SENA - Servicio Nacional de Aprendizaje
46 /** @param newVal */
47 protected function setCargo($newVal)
34 }
35
36 protected function getNombre()
37 {
39 }
40
41 protected function getSalario()
42 {
44 }
45
47 protected function setCargo($newVal)
48 {
49 $this->cargo = $newVal;
50 }
51
53 protected function setIdentificacion($newVal)
54 {
55 $this->identificacion = $newVal;
56 }
57
59 protected function setNombre($newVal)
60 {
61 $this->nombre = $newVal;
62 }
63
65 protected function setSalario($newVal)
66 {
67 $this->salario = $newVal;
68 }
69 }
70 ?>
71
22
Código Clase Contratista
1 <¿php
2 /**
4 * @version 1.0
5 * @created 20-oct-2013 07:47:29 a.m.
6 */
7 class Contratista extends Empleado
8 {
9 private $totalHoras;
10 private $valorHora;
11
12 //Constructor
13 public function
14 Contratista($identificacion,$nombre,$cargo)
15 {
16 //ejecutamos el connstructor de la clase Padre Empleado
17 parent::__construct($identificacion,$nombre,$cargo);
18 }
19
20 /** @param totalHoras, @param valorHora */
21 public function calcularSalario($valorHora, $totalHoras)
22 {
23 $this->salario= $valorHora*$totalHoras;
24 }
25
26 public function getTotalHoras()
27 {
28 return $this->totalHoras;
29 }
30
31 public function getValorHora()
32 {
33 return $this->valorHora;
34 }
35
36 public function getCargo()
37 {
39 }
40
41 public function getIdentificacion()
42 {
23 44 }
46 {
34 }
35
37 {
39 }
40
42 {
44 }
46 {
48 }
49
50 public function getSalario()
51 {
53 }
54
56 public function setTotalHoras($newVal)
57 {
58 $this->totalHoras = $newVal;
59 }
60
62 public function setValorHora($newVal)
63 {
64 $this->valorHora = $newVal;
65 }
66 }
67 ?>
68
24
Código Clase Planta
1 <¿php
2 /**
4 * @version 1.0
5 * @created 20-oct-2013 07:47:30 a.m.
6 */
7 class Planta extends Empleado
8 {
9 private $deducciones;
10 private $sueldoBasico;
11 private $valorExtras;
12
13 //Constructor
14 public function Planta($identificacion,$nombre,$cargo)
15 {
16 //ejecutamos el constructor de la clase Padre Empleado
17 parent::__construct($identificacion,$nombre,$cargo);
18 }
19 public function calcularSalario()
20 {
21 $this->salario=$this->sueldoBasico + $this->valorExtras -
22 $this->deducciones;
23 }
24
25 public function getDeducciones()
26 {
27 return $this->deducciones;
28 }
29
30 public function getSueldoBasico()
31 {
32 return $this->sueldoBasico;
33 }
34
35 public function getValorExtras()
36 {
37 return $this->valorExtras;
38 }
39
41 {
43 }
25 44
46 {
34
35 public function getValorExtras()
36 { Programación Orientada a Objetos en PHP
37 return $this->valorExtras;
38 }
39
41 {
43 }
44
46 {
48 }
49
51 {
53 }
54
55 public function getSalario()
56 {
58 }
59
61 public function setDeducciones($newVal)
62 {
63 $this->deducciones = $newVal;
64 }
65
67 public function setSueldoBasico($newVal)
68 {
69 $this->sueldoBasico = $newVal;
70 }
71
73 public function setValorExtras($newVal)
74 {
75 $this->valorExtras = $newVal;
76 }
77
78 }
79 ?>
80
26
Código de la Implementación Empleado Planta

1 <¿php
2 include ('Empleado.php');
3 include "Planta.php";
4
5 echo "Calcular Salario Empleado";
6 echo " ";
7 //Datos de Entrada Empleado de Planta
8 $tipoEmpleado = "Planta";
9 $identificacion="456";
10 $nombre="Faustino Asptrilla";
11 $cargo = "Gerente";
12 $SueldoBasico = 4500000;
13 $valorExtras=345000;
14 $deducciones=1098000;
15
16 //Creamos el objeto
17 $objPlanta = new Planta($identificacion,$nombre,$cargo);
18
19 //modificamos atributos del empleado de planta
20 $objPlanta->setSueldoBasico($SueldoBasico);
21 $objPlanta->setValorExtras($valorExtras);
22 $objPlanta->setDeducciones($deducciones);
23
24 //imprimimos datos de entrada
25 echo " id Empleado: " . $objPlanta->getIdentificacion();
26 echo " Nombree Empleado: " . $objPlanta->getNombre();
27 echo " Cargo Empleado: " . $objPlanta->getCargo();
28 echo " Sueldo Basico: $" . $objPlanta->getSueldoBasico();
29 echo " Valor Extras: $" . $objPlanta->getValorExtras();
30 echo " Total Deducciones: $" . $objPlanta->getDeducciones();
31
32 echo " RESULTADOS ";
33
34 //calculam os el salario del empleado de planta
35
36 $objPlanta->calcularSalario();
37
38 //Mostramos resultados
39
40 echo " id Empleado: " . $objPlanta->getIdentificacion();
41 echo " Nombree Empleado: " . $objPlanta->getNombre();
42 echo " Cargo Empleado: " . $objPlanta->getCargo();
43 echo " Salario Neto a Recibir: $" . $objPlanta->getSalario();
44
45 ?>
46
27
Código Implementación Empleado Contratista
1 <¿php
2 include ('Empleado.php');
3 include "Contratista.php";
4
5 //Datos de Entrada Empleado Contratista
6
7 echo "Calcular Salario Empleado Contratista ";
8 echo " ";
9 $tipoEmpleado = "Contratista";
10 $identificacion = "123";
11 $nombre = "Angie Cepeda";
12 $cargo = "Secretaria";
13 $totalHorasTrabajadas = 160;
14
15 //Creamos el objeto
16 $objContratista = new Contratista($identificacion,$nombre,$cargo);
17
18 //modificamos atributos del empleado de Contrato
19 $objContratista->setvalorHora(4000);
20 $objContratista->setTotalHoras($totalHorasTrabajadas);
21
22 //imprimimos datos de entrada
23 echo " id Empleado: " . $objContratista->getIdentificacion();
24 echo " Nombree Empleado: " . $objContratista->getNombre();
25 echo " Cargo Empleado: " . $objContratista->getCargo();
26 echo " Valor de la Hora: $" . $objContratista->getValorHora();
27 echo " Total Horas Trabajas en el Mes: " . $objContratista->getTotalHoras();
28
29 echo " RESULTADOS ";
30
31 //calculam os el salario del empleado de Contrato
32 $objContratista->calcularSalario(4000,$totalHorasTrabajadas);
33
34 //Mostramos resultados
35 echo " id Empleado: " . $objContratista->getIdentificacion();
36 echo " Nombree Empleado: " . $objContratista->getNombre();
37 echo " Cargo Empleado: " . $objContratista->getCargo();
38 echo " Salario Neto a recibir en el Mes: " . $objContratista->getSalario();
39
40 ?>
41
42
28
Resultados Implementación Empleado Planta
localhost
localhost/salario/salarioPlanta.php
Calcular Salario Empleado
id Empleado: 456
Nombre Empleado: Faustino Asprilla
Cargo Empleado: Gerente
Valor de la Hora: $4500000
Valor Extras: $345000
Total Deducciones: $1098000
RESULTADOS
id Empleado: 456
Nombre Empleado: Faustino Asprilla
Cargo Empleado: Gerente
Salario Neto a Recibir: $3747000
Resultado implementación Empelado Contratista

localhost
localhost/salario/salariocontratista.php
Calcular Salario Empleado Contratista
id Empleado: 123
Nombre Empleado: Angie Cepeda
Cargo Empleado: Secretaria
Valor de la Hora: $4000
Total Horas Trabajadas en el Mes: 160
RESULTADOS
id Empleado: 123
Nombre Empleado: Angie Cepeda
Cargo Empleado: Secretaria
Salario Neto a recibir en el Mes: 640000
29
RECURSOS BIBLIOGRÁFICOS
Programación Orientada a Objetos en PHP. http://www.phpya.com.ar/

poo/
Cobo, Angel. Gomez Patricia, Perez Daniel, Rocha Rocio. PHP y MySQL:
Tecnología para el desarrollo de aplicaciones web.
Programación Orientada a Objetos en PHP. http://www.php.net/manual/

es/language.oop5.php
Recursos en Videotutoriales Programación Orientada a Objetos en PHP.

http://www.cesarcancino.com/?cat=2
Place, Enrique. Programación Orientada a Objetos en PHP 5. http://www.

surforce.com
30
GLOSARIO
POO: Programación Orientada a Objetos.
__construct: Método Constructor de una clase en PHP.
__destruct: Método destructor de una clase en php.
$this=Variable que se utiliza en una clase para poder acceder a los

métodos o atributos de la clase.
class = Palabra reservada utilizada en la definición de una clase.
extends = Palabra utilizada en la definición de una clase que hereda a

otra clase.
31
PROGRAMACIÓN ORIENTADA A
OBJETO DE APRENDIZAJE
OBJETOS EN PHP
Desarrollador de contenido César Marino Cuéllar Chacón

Experto temático
Asesor Pedagógico Rafael Neftalí Lizcano Reyes
Manuel Francisco Silva Barrera

Productores Multimedia Luisa Fernanda Bolivar
Programador Daniel Eduardo Martínez Díaz
Líder expertos temáticos Ana Yaqueline Chavarro Parra
Líder línea de producción Santiago Lozada Garcés
R
El logo de PHP® es una marca registrada, una subsidiaria de Sun
Microsystems y esta a su vez de Oracle Corporation.
Registered trademark
32

Prog or Obj PHP PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Prog or Obj PHP PDF

Cargado por

Copyright:

Formatos disponibles

PROGRAMACIÓN ORIENTADA A OBJETOS EN PHP

Programa: ANÁLISIS Y DESARROLLO DE SISTEMAS DE

Duración estimada de estudio (horas): 6 horas

FAVA - Formación en Ambientes Virtuales de Aprendizaje SENA - Servicio Nacional de Aprendizaje

Programación Orientada a Objetos en PHP.

Al revisar los conceptos relacionados con la construcción de sistemas de

El presente objeto de aprendizaje, presenta los conceptos y recursos que

1. Definición de una clase en PHP

Una clase inicia con la palabra reservada class en minúscula y después el

Declaración de Clases Abstractas

abstract class NombreClase{

//No necesita ser instanciada

Declaración de Clases Final

final class NombreClase{

//esta clase no puede ser heredada

1.1 Estructura General de una Clase en PHP.

La siguiente figura presenta la estructura general de una clase, la definición

Ahora vamos a mostrar la implementación de una clase denominada

1.2 Los Atributos

Los atributos son las características, cualidades, propiedades distintivas

Cuando creamos un objeto de una clase determinada, los atributos

1.3 Los constructores

El constructor es un método especial de una clase. El objetivo fundamental

Se pueden definir varios constructores (sobrecarga de constructores),

Se pueden definir de dos formas:

1. Mediante un método llamado __construct

2. Mediante un método llamado igual que el nombre de la clase.

Otras características de los constructores son:

• El constructor se ejecuta inmediatamente luego de crear un objeto y

• Un constructor no puede retornar dato.

• Un constructor puede recibir parámetros que se utilizan normalmente

• El constructor es un método opcional, de todos modos es muy común

1.4 Los Métodos

El objetivo de un método es ejecutar las actividades que tiene encomendada

Los atributos de un objeto se modifican mediante llamadas a sus métodos.

Ejemplo Definición de Métodos

public function setNombre($value)

En los ejemplos anteriores el primer método retorna un valor para ello se

La encapsulación en un programa se da cuando se definen los atributos

1.6 Modificadores de Acceso

Public: Cuándo un atributo o un método es definido como public se puede

public function metodo()

Private: Cuando un atributo o un método es definido como private, solo

Protected: Cuando un atributo o método es definido como protected,

2. Representación de las Relaciones entre Clases

2.1 Relación de Dependencia

La relación de dependencia es cuando una clase depende de la funcionalidad

class Class Model

Ahora como se traduce en código PHP:

2.2 Relación de Agregación

Ahora como se traduce en PHP:

2.3 Relación de Composición

Similar a la relación de agregación solo que en está relación existe una

En esta relación la empresa existe si tiene empleados. El código en PHP

Para crear un objeto, es necesario emplear alguno de los constructores de

Desde un archivo php podemos tener el siguiente código para crear un

$objeto = new Clase();

$objeto = new Clase($parametros);

En la creación del objeto encontramos la sentencia new y después va el

3.1 Ejemplo de construcción de objetos

En la siguiente imagen se relaciona el ejemplo completo:

Explicación línea por línea.

<?php Código de inicio del código php.