Programacion_orientada_a_objetos_en_php

Vista previa del material en texto

FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje.
Programación
orientada
a objetos en
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
2SENA - Servicio Nacional de Aprendizaje.
ESTRUCTURA DE CONTENIDOS
Pág.
Introducción .......................................................................................................................4
Mapa de contenido ............................................................................................................5
1. Definición de clases. .....................................................................................................6
1.1. Clases corrientes o regulares. ....................................................................................6
1.2. Clases abstractas. ......................................................................................................6
1.5. Los atributos. ..............................................................................................................9
1.6. Los constructores. ......................................................................................................9
1.7. Los métodos. ............................................................................................................11
1.8. Encapsulamiento. .................................................................................................... 12
2. Representación de las relaciones entre clases. ......................................................... 15
2.1. Relación de dependencia. ....................................................................................... 15
2.2. Relación de agregación. .......................................................................................... 15
2.3. Relación de composición......................................................................................... 16
3. Los objetos. ................................................................................................................ 17
3.1. Ejemplo de construcción de objetos. ....................................................................... 17
3.2. Herencia. ................................................................................................................. 19
3.3. Ejecución de métodos. ............................................................................................ 22
3.4. El operador de resolución de ámbito “::”. ................................................................ 22
3.5. La palabra reservada “static”. .................................................................................. 22
3.6. La palabra reservada “self” y “parent”. .................................................................... 23
3.7. Polimorfismo. ........................................................................................................... 24
4. Usos prácticos de objetos. ......................................................................................... 25
4.1. Acceso a bases de datos......................................................................................... 25
4.2. Captura de los registros de una base de datos. ...................................................... 26
5 Ejercicio de ejemplo. ................................................................................................... 27
5.1. Enunciado................................................................................................................ 27
5.2. Desarrollo del ejercicio. ........................................................................................... 27
Glosario .......................................................................................................................... 44
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
3SENA - Servicio Nacional de Aprendizaje.
Bibliografía...................................................................................................................... 46
Control del documento ................................................................................................... 47
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
4SENA - Servicio Nacional de Aprendizaje.
PROGRAMACIÓN ORIENTADA A OBJETOS EN PHP
En el desarrollo de sistemas de información el paradigma de la programación orientada 
a objetos permite una mejor mantenibilidad y reutilización de código en comparación con 
el paradigma de programación estructurada.
En este recurso se presentarán los fundamentos de programación orientada a objetos 
como son: herencia, encapsulamiento y polimorfismo y su implementación en el lenguaje 
de programación PHP.
Para una mejor comprensión se requiere que el aprendiz haya revisado el objeto de 
aprendizaje “Fundamentos de programación con PHP” y el objeto “Introducción al diseño 
web usando HTML”.
INTRODUCCIÓN
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
5SENA - Servicio Nacional de Aprendizaje.
MAPA DE CONTENIDO
Programación
orientada
a objetos en
Tipos de Clases
Atributos
Métodos
Elementos de
una Clase
tipos de
Clase
abstracta
Public
Private
Protected Destructor
Son los programas
o funciones incorporados
dentro de la clase
Setters o
fijadores
Getters o
consultores
Constructor
qué son
qué son
Modificadores
de acceso a los
atributos
Clase
finalClase
normal
Son las características o
propiedades de la clase
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
6SENA - Servicio Nacional de Aprendizaje.
DESARROLLO DE CONTENIDOS
1. Definición de clases. 
Las clases son la base de la programación orientada a objetos y actúan como una plantilla 
sobre la cual se crean los objetos.
La definición de una clase de pude realizar dentro del programa principal o en un programa 
aparte. Para poder utilizar las clases almacenadas en otros archivos estos últimos se 
deben agregar al programa usando la instrucción “include” o “include_once”.
Dependiendo de su tipo las clases pueden ser:
1.1. Clases corrientes o regulares.
Una clase inicia con la palabra reservada “class” en minúscula y después el nombre de 
la misma.
1
2
3
4
5
6
7
<?php
class NombreClase
{
 // el código va aquí
}
?>
Figura 1.1. Definición de clases corrientes
1.2. Clases abstractas.
Las clases abstractas son aquellas que no pueden ser instanciadas pero pueden ser 
heredadas. Se definen anteponiendo la palabra abstract. 
1
2
3
4
5
6
7
<?php
 abstract class NombreClase{
 //No puede ser instanciada.
}
?>
Figura 1.2. Definición de clases abstractas
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
7SENA - Servicio Nacional de Aprendizaje.
1.3. Definición de una clase final
PHP incorpora clases finales que no permiten ningún tipo de herencia. Se definen 
anteponiendo la palabra reservada final.
1
2
3
4
5
6
7
8
9
<?php
 final class NombreClase{
 //Esta clase no permite ningún tipo de herencia
 //No se puede hacer lo siguiente : 
 // class OtraClase extends claseFinal {
 // este código genera un error.
 // } ;
}
?>
Figura 1.3. Definición de clases finales.
1.4. Estructura general de una clase.
El siguiente código 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
2
3
4
5
6
7
8
9
<?php
 class NombreClase
 {
 //Definición de Atributos
 //Definición Constructor
 //Definición de destructor (opcional)
 //Definición de Métodos
}
?>
Figura 1.4. Estructura general de una clase.
Programación orientada a objetos en php
FAVA - Formaciónen Ambientes Virtuales de Aprendizaje
8SENA - Servicio Nacional de Aprendizaje.
A continuación se muestra la implementación de una clase denominada “Persona”.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<?php
class Persona
{
//Definición de Atributos
private $nombre;
//Constructor
public function Persona($nombre)
 {
 $this->nombre=$nombre;
 }
//Definición de Métodos
 public function getNombre()
 {
 return $this->nombre;
 }
public function setNombre($value)
 {
 $this->nombre=$value;
 }
public function leer($libro)
 {
 //aquí va el código del método
 }
}
?>
Figura 1.5. Ejemplo de definición de una clase.
En la definición de una clase aparece una pseudo variable llamada “$this” que representa 
el objeto que se está construyendo. No se debe confundir con la palabra reservada “self” 
que se usa para acceder a las propiedades y métodos estáticos de la clase.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
9SENA - Servicio Nacional de Aprendizaje.
1.5. 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. 
Cuando se crea un objeto de una clase los atributos declarados son localizados en 
memoria y pueden ser modificados mediante los métodos.
Es conveniente que los atributos sean privados para que solo los métodos de la clase 
puedan modificarlos usando los llamados “setters” o fijadores y los “getters” o consultores.
A continuación un ejemplo de definición de métodos privados.
1
2
3
4
5
6
7
8
<?php
 class NombreClase{
 //Definición de Atributos
 private $identificación;
 private $nombre;
 private $fechanacimiento;
}
?>
Figura 1.6. Ejemplo de atributos privados
1.6. Los constructores.
El constructor es un método especial de una clase. Su objetivo fundamental es inicializar 
los atributos del objeto que se crea.
Se pueden definir varios constructores (sobrecarga de constructores) que permitan crear 
el objeto de diferentes maneras.
Se pueden definir de dos formas:
1. Mediante un método llamado “__construct”
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
10SENA - Servicio Nacional de Aprendizaje.
1
2
3
4
5
6
7
8
9
<?php
 class NombreClase{
 //Constructor
 public function __construct($nombre);
 {
 $this->nombre=$nombre;
 } 
 }
?>
Figura 1.7. Ejemplo del constructor: __construct
2. Mediante un método llamado igual que el nombre de la clase.
1
2
3
4
5
6
7
8
9
<?php
 class Persona{
 //Constructor
 public function Persona($nombre);
 {
 $this->nombre=$nombre;
 } 
 }
?>
Figura 1.8. Ejemplo de constructor de igual nombre que la clase.
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 datos.
• Un constructor puede recibir parámetros que se utilizan normalmente para 
inicializar atributos.
• El constructor es un método opcional.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
11SENA - Servicio Nacional de Aprendizaje.
1.7. Los métodos.
Los métodos son funciones que están definidas dentro de una clase y operan sobre los 
atributos de dicha clase además permiten definir las funcionalidades o responsabilidades 
de la clase. 
El objetivo de un método es ejecutar las actividades que tiene encomendada la clase a 
la cual pertenece.
Los atributos de un objeto se modifican mediante llamadas a sus métodos. A continuación 
un ejemplo de definición de métodos:
1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
 class NombreClase{
 //Definición de Métodos
 public function getNombre()
 {
 return $this->nombre;
 }
 public function setNombre($value)
 {
 $this->nombre=$value;
 }
 }
?>
Figura 1.9. Ejemplo de definición de métodos
En los ejemplos anteriores el primer método retorna un valor para ello se utiliza la 
sentencia:
return $variable;
Este tipo de métodos se conocen como “getters”. Se acostumbra a incluir en el nombre 
del método la palabra inglesa “get” de manera informativa.
El segundo método recibe un parámetro y este parámetro es asignado al atributo nombre: 
$this->nombre=$value;
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
12SENA - Servicio Nacional de Aprendizaje.
Este tipo de métodos se conocen como “setters”. Se acostumbra a incluir en el nombre 
del método la palabra inglesa “set” de manera informativa.
1.8. Encapsulamiento.
El encapsulamiento se da cuando los atributos de una clase no pueden ser modificados 
o consultados directamente sino a través de los métodos implementados.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<?php
 class Persona
 {
 //Definición de Atributos
 private $value;
 private $nombre;
 private $fechanacimiento;
 //Constructor
 public function Persona($nombre)
 {
 $this->nombre=$nombre;
 }
 //Definición de Métodos
 public function getNombre()
 {
 return $this->nombre;
 }
 public function setNombre($value)
 {
 $this->nombre=$value;
 }
 public function getIdentificación()
 {
 return $this->identificación;
 }
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
13SENA - Servicio Nacional de Aprendizaje.
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
 public function setidentificación($value)
 {
 $this->nombre=$value;
 }
 public function getFechaNacimiento()
 {
 return $this->fechaNacimiento;
 }
 public function setFechaNacimiento($value)
 {
 $this->fechaNacimiento=$value;
 } 
 }
?>
Figura 1.10. Ejemplo de encapsulamiento.
1.9. Modificadores de acceso.
Son los que modifican la visibilidad tanto de los atributos como los métodos. Se clasifican 
en:
1.9.1 Public:
Cuando un atributo o un método es definido como “public” se puede acceder a él 
directamente desde el programa que haya instanciado el objeto. Ejemplo:
1
2
3
4
5
6
7
8
9
<?php
 class NombreClase{
 //Constructor
 public Atributo;
 {
 return $valor;
 } 
 }
?>
Figura 1.11. Ejemplo de un método público.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
14SENA - Servicio Nacional de Aprendizaje.
1.9.2. Private.
Cuando un atributo o un método es definido como “private”, solo se puede acceder a ellos 
desde la misma clase. Ejemplo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
 class NombreClase{
 //Definición de Atributos
 private $identificación;
 private $Nombre;
 private $fechanacimiento;
 //Definición de Atributos
 private function operacion($valor1)
 {
 return $valor*2;
 } 
 }
?>
Figura 1.12. Ejemplo de un método privado.
1.9.3. 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. Ejemplo:
1
2
3
4
5
6
7
<?php
 class NombreClase{
 //Definición de Atributos
 protected $identificación;
 protected $Nombre;
 }
?>
Figura 1.13. Ejemplo de un método “protected”.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
15SENA - Servicio Nacional de Aprendizaje.
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 lafuncionalidad que ofrece 
otra clase.
class Class Model
Motor
- cilindraje
+ getCilindraje() : var
+ Motor(var) : void
Carro
+ mostrarMotor(Motor):void
Figura 2.1 Modelo de clases con relación de dependencia.
En php se implementa así:
1
2
3
4
5
6
7
8
9
10
<?php
require_once ('Motor.php');
 class Carro
 {
 function mostrarMotor(Motor $objetoMotor)
 {
 echo $objetoMotor->getCilindraje();
 }
 }
?>
Figura 2.2. Ejemplo de clase con dependencia.
2.2. Relación de Agregación.
Es una relación de asociación donde una de las clases forma parte del todo o está 
completamente inmersa en otra clase.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
16SENA - Servicio Nacional de Aprendizaje.
Curso
- aprendices: array
+ mostrarMotor(Motor):void
Aprendices
Figura 2.3. Modelo de clases con agregación.
En php se implementa así:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?php
require_once (Aprendices.php');
class Curso
{
 //Se define un arreglo donde se van a guardar los aprendices
 private $aprendices = array();
 function agregarAprendices(Aprendices $aprendiz)
 {
 //se agrega al arreglo $aprendices el objeto aprendiz
 this->aprendices[] = $aprendiz;
 }
}
 $objCurso = new Curso();
 $objCurso->agregarAprendices(new Aprendices());
 $objCurso->agregarAprendices(new Aprendices());
 $objCurso->agregarAprendices(new Aprendices());
 $objCurso->agregarAprendices(new Aprendices());
 $objCurso->agregarAprendices(new Aprendices());
 /* Como ejemplo en el curso anterior solo se agregaron 5 aprendices */
?>
Figura 2.4. Ejemplo de relación de agregación.
2.3. Relación de Composición.
Similar a la relación de agregación solo que en esta relación existe una relación de 
existencia. Por ejemplo:
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
17SENA - Servicio Nacional de Aprendizaje.
Empresa Empleado
Figura 2.5. Diagrama de clases con composición.
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.
Una vez definidas las clases se pueden crear o instanciar objetos. 
El siguiente código crea un objeto.
$objeto = new Clase();
$objeto = new Clase($parametros):
En la creación de los objetos se usa la sentencia “new” y después el nombre de la clase. 
Al momento de instanciar se ejecutan automáticamente los métodos constructores que 
tenga la clase. 
Por lo tanto se puede crear un objeto de diferentes formas dependiendo del número de 
constructores.
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:
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
18SENA - Servicio Nacional de Aprendizaje.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<!DOCTYPE html>
<html>
 <body>
 <?php
 //se incluye el archivo donde esta el código de la
 clase Persona
 include “Persona.php”;
 
 //Se instancia el primer Objeto
 $objPersona=new Persona(“Pedro Picapiedra”);
 //Instanciamos
 
 /* Para poder mostrar en pantalla el nombre de la 
 persona se debe utilizar el método gerNombre(), ya que 
 el atributo $nombre es privado.*/
 //Ahora se instancia otra vez la clase persona
 
 $objPersona=new Persona(“Vilma”);
 echo “<br> Nombre del segundo obeto Persona : ”.
 $objPersona->getNombre();
 
 ?>
 </body>
</html>
Figura 3.1. Ejemplo de instanciación de objetos.
Código Comentarios
<?php Código de inicio del código php.
Include “Persona.php” Es la forma como se incluye un archivo en php. Aquí se 
está incluyendo el archivo Persona.php que contiene el 
código de la clase persona.
$objPersona = new 
Persona(“Pedro Picapiedra”)
Esta línea crea un objeto llamado $objPersona y se está 
pasando como parámetro el valor de “Pedro Picapiedra”.
echo “<br>
Nombre del Primer obeto 
Persona:
” . $ o b j P e r s o n a -
>getNombre();
En esta línea se obtiene el nombre de la persona 
mediante el método getNombre() de la clase persona y 
lo imprime en pantalla.
Se debe utilizar ese método debido a que el atributo 
Nombre está definido como private.
?> Etiqueta de cierre del código php.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
19SENA - Servicio Nacional de Aprendizaje.
El resultado final al ejecutar el código es el siguiente:
Figura 3.2. Resultados de la instanciación de objetos. 
3.2. Herencia.
La herencia permite crear nuevas clases partiendo de las ya existentes. En la herencia 
existe el concepto de superclase o clase padre y la clase que hereda se le conoce como 
clase hija.
Definición de una clase que hereda de otra. Ejemplo:
class Hija extends Padre
{
}
Como ejercicio se va a crear una clase Estudiante que hereda la clase Persona.
Para ello lo primero que se hace es modificar la clase Persona. Luego se declara el 
atributo “nombre” como “protected”.
1
2
3
4
5
6
7
8
9
10
<?php
 include “Persona.php”;//Se incluye para poder acceder 
 a ella
 class Estudiante extends Persona
 {
 //Atributo curso: Que curso estudia el Estudiante.
 private $curso;
 //Método que obtiene el curso que estudia el 
 estudiante.
 public function getCurso()
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
20SENA - Servicio Nacional de Aprendizaje.
11
12
13
14
15
16
17
18
19
20
21
22
23
24
26
27
28
29
30
 {
 return $this->curso;
 }
 
 //Método que permite cambiar el curso del 
 estudiante.
 public function setCurso($value)
 {
 $this->curso=$value;
 }
 
 //Constructor Clase Estudiante
 public function Estudiante($nombre, $curso)
 {
 $this->nombre=$nombre;
 $this->curso=$curso;
 }
 }
?>
Figura 3.3. Ejemplo de definición de una clase con herencia.
Ahora se importa la definición de la clase en un nuevo programa donde se puede crear 
un objeto de la clase “Estudiante”.
1
2
3
4
5
6
7
8
<?php
 //Se incluye el archivo donde está el
 código de la clase Persona
 include Estudiante.php”;
 //Se instancia para crear el primer
 objeto tipo Estudiante
 $ObjEstudiante=new Estudiante($nombre,$curso)
?>
Figura 3.4. Ejemplo instanciación de una clase con herencia.
En el ejemplo anterior se deberán suministrar los parámetros $nombre y $curso al 
momento de instanciar un objeto de clase “Estudiante”.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
21SENA - Servicio Nacional de Aprendizaje.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
26
27
<html>
 <body>
 <?php
 //Se incluye el archivo donde está el código de la clase Persona
 include "Estudiante.php";
 
 //Se instancia el primer objeto tipo Estudiante
 $objEstudiante=new Estudiante("César Cuéllar", "ADSI");
 
 //Se crea otro objeto de tipo Estudiante
 $objEstudiante2=new Estudiante2("Marcela Méndez", "Multimedia");
 echo "ESTUDIANTES INSCRITOS<BR>";
 
 /*Se muestra por pantalla los datos de los estudiantes
 Se accede al método getNombre() que lo hereda de la clase persona*/
 echo "<br> Nombre del Estudiante : ". $objEstudiante->getNombre();
 
 /*Ahora se va a imprimir en pantalla el Curso, para ello
 se accede al método getCurso() propio de la clase Estudiante.*/
 echo "<br> Curso que se encuentra el Estudiante : ". $objEstudiante->getNombre();
 echo "<br> Nombre del Estudiante : ". $objEstudiante2->getNombre();
 echo "<br> Curso que se encuentra el Estudiante : ". $objEstudiante2->getNombre();
 ?>
 </body>
</html>
Figura 3.5. Ejemplo completo de herencia.
Resultado de la Implementación:
Figura3.6. Resultado del ejemplo de herencia.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
22SENA - Servicio Nacional de Aprendizaje.
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”);
echo “el curso del estudiante es “. $objEstudiante->getCurso(); 
Si el método no tiene parámetros se debe finalizar con un “()”.
3.4. El operador de resolución de ámbito “::”.
El operador de resolución de ámbito permite acceder a elementos estáticos y constantes 
y sobreescribir propiedades o métodos de una clase (COWBORN,2017).
Hasta el momento solo se hacían operaciones sobre los objetos sin embargo en algunos 
momentos es útil poder acceder a los elementos constantes y estáticos de la definición 
de una clase.
1
2
3
4
5
6
7
8
9
10
11
<html>
 <body>
 <?php
 class mi_clase {
 const MI_CONSTANTE = 'Valor constante';
 }
 echo mi_clase::MI_CONSTANTE ;
 ?>
</body>
</html>
Figura 3.7. Ejemplo del operador de resolución de ámbito.
3.5. La palabra reservada “static”.
Definir un método o una propiedad como estática permite que pueda ser accedido sin 
necesidad de instanciar un objeto, es decir, se puede consultar directamente la definición 
de la clase.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
23SENA - Servicio Nacional de Aprendizaje.
1
2
3
4
5
6
7
8
9
10
11
12
13
<html>
<body>
 <?php
 class mi_clase {
 public static function mi_metodo_estatico(){
 echo "soy un método estático";
 }
 }
 echo mi_clase::mi_metodo_estatico() ;
 ?>
 </body>
</html>
Figura 3.8. Ejemplo de un método estático.
3.6. La palabra reservada “self” y “parent”.
Estas variables permiten acceder a la clase padre en el caso de “parent” o a los métodos 
estáticos de la misma clase con “self” como se ilustra en el siguiente ejemplo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
26
27
<html>
 <body>
 <?php
 class mi_clase {
 public static function mi_metodo_estatico(){
 echo 'soy un método estático';
 }
 }
 class mi_clase_hija extends mi_clase {
 
 public static $variable_estatica = 'soy una variable estática';
 
 public static function mi_metodo_hijo() {
 echo parent::mi_metodo_estatico()."<br>";
 echo self::$variable_estatica;
 
 }
 }
 echo mi_clase::mi_metodo_estatico()."<br>" ;
 echo mi_clase_hija::mi_metodo_hijo();
 ?>
 </body>
</html>
Figura 3.9. Ejemplo de uso de “parent” y “self”.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
24SENA - Servicio Nacional de Aprendizaje.
3.7. Polimorfismo.
Una de las ventajas de la programación orientada a objetos es que una misma interfaz 
(conjunto de nombres de métodos) puede generar objetos que se comportan de manera 
distinta.
Lo anterior se conoce como polimorfismo y es útil para disminuir la cantidad de código y 
hacer los programas más entendibles.
A continuación, un ejemplo que usa clases abstractas para implementar polimorfismo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?php
 abstract class moneda {
 abstract public function convertir_a_pesos($cantidad);
 }
 }
 class Dolar extends moneda {
 public function convertir_a_pesos($cantidad){
 return $cantidad * 3000 ;
 }
 }
 
 class Euro extends moneda {
 public function convertir_a_pesos($cantidad){
 return $cantidad * 4000 ;
 }
 }
 $dolar = new Dolar ;
 echo $dolar->convertir_a_pesos(100) . "<br>";
 $euro = new Euro ;
 echo $euro->convertir_a_pesos(100);
?>
Figura 3.10. Implementación de polimorfismo con clases abstractas.
En el anterior ejemplo tanto la clase “Dolar” como la clase “Euro” hacen uso de la clase 
abstracta “moneda” cuyo método “convertir_a_pesos” se implementa de forma diferente 
en cada una de las clases hijas.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
25SENA - Servicio Nacional de Aprendizaje.
El anterior ejemplo se puede implementar haciendo uso de la palabra reservada “interface” 
así:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?php
 Interface moneda {
 public function convertir_a_pesos($cantidad);
 }
 }
 class Dolar implements moneda {
 public function convertir_a_pesos($cantidad){
 return $cantidad * 3000 ;
 }
 }
 
 class Euro extends moneda {
 public function convertir_a_pesos($cantidad){
 return $cantidad * 4000 ;
 }
 }
 $dolar = new Dolar ;
 echo $dolar*convertir_a_pesos(100) . "<br>";
 $euro = new Euro ;
 echo $euro*convertir_a_pesos(100);
?>
Figura 3.11. Implementación de polimorfismo con interfaces.
En resumen una interfaz en PHP es una clase abstracta donde todos los métodos son 
abstractos.
4. Usos prácticos de objetos.
4.1. Acceso a bases de datos.
Los objetos se pueden usar para manejar las conexiones a las bases de datos.
Para conectarse a una base de datos MySQL se usa el siguiente código que fue introducido 
en al objeto de aprendizaje “Fundamentos de programación con PHP”:
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
26SENA - Servicio Nacional de Aprendizaje.
1
2
3
4
5
6
7
8
9
10
11
<?php
 $conn = new mysqli("localhost", "desarrollador", 
 "adsi2017", "citas" ) ;
 if( $conn->connect_errno) {
 echo "Falla al conectarse a Mysql
 ( ". $conn->connect_errno . ") " . 
 $conn->connect_error ;
 } else {
 echo $conn->host_info. "\n" ;
 } ;
?>
Figura 4.1. Creación de objeto para conexión a bases de datos.
En el anterior ejemplo la clase “mysqli” (MySQL Improved) instancia el objeto llamado 
“$conn”. Además, se consultan los siguientes atributos:
$conn→connect_errno: contiene el código de error o 0 en caso de que no haya.
$conn→connect_error: contiene la descripción del error.
$conn→host_info: contiene información del host donde se está ejecutando PHP.
Cuando se termina la ejecución del programa se deben ejecutar el siguiente método:
$conn→close(): Cierra la conexión.
4.2. Captura de los registros de una base de datos.
La extensión “mysqli” implementa el método “fetch_object” el cual crea un objeto para 
cada registro que se trae de la base de datos. Este método convierte cada campo del 
registro generado en la consulta en un atributo del objeto. A continuación un ejemplo:
1
2
3
4
5
6
7
8
9
<?php
 if( $resultado = $conn->query(("select codigo, nombre from ciudades ") ) {
 while($registro = $resultado->fetch_object() ){
 echo $registro->codigo . " " . $registro->nombre . "\n" ;
 } else {
 echo $conn->host_info. "\n" ;
 } ;
?>
Figura 4.2. Ejemplo de registro implementado en un objeto.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
27SENA - Servicio Nacional de Aprendizaje.
Se puede observar que la variable “$resultado” es un objeto que fue instanciado con el 
método “fetch_object” y contiene los atributos “codigo” y “nombre”.
5 ejercicio de ejemplo.
5.1. 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.
A los contratistas el salario depende del valor de la hora.
Formula: Salario = ValorHora * TotalHoras
El salario de los empleados de planta depende del sueldo básico mensual.
Formula = SalarioBasico + HorasExtras – deducciones.
5.2. Desarrollo del ejercicio.
Para este ejercicio se van a utilizar los siguientes conceptos ya vistos tanto en este 
recurso como en los objetos deaprendizaje: “Fundamentos de programación con PHP” y 
“Introducción al diseño web con HTML” a saber:
1. Paso de variables a un programa PHP por el método get.
2. Definición de clases.
3. Creación y manipulación de objetos.
4. Creación de formularios y tablas en HTML.
5. Utilización del patrón modelo, vista, controlador o MVC.
Para mejorar la presentación de los formularios se hará uso del framework o librería CSS 
llamada Bootstrap. Esta última se añade al proyecto así:
<html>
 <head>
 link rel=”stylesheet” href=”https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/
bootstrap.min.css”>
 </head>
<body>
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
28SENA - Servicio Nacional de Aprendizaje.
5.2.1 Diagrama de Clases.
class Class Model
Empleado
# Identificacion: int
# nombre: string
# salario: float
+ Empleado(var,var,var) : void
+ getcargo() : var
+ getidentificacion() : var
+ getnombre() : var
+ getsalario() : var
+ setcargo(var) : void
+ setidentificacion(var) : void
+ setnombre(var) : void
+ setsalario(var) : void
Contratista
- totalHoras: int
- valorHora: float
+ CalcularSalario(var,var)
+ Contratista() : void
+ getcargo() : var
+ getidentificacion() : var
+ getnombre() : var
+ getsalario() : var
+ gettotalHoras() : var
+ getvalorHoras() : var
+ settotal(var) : void
+ setvalorHoras(var) : void
Planta
- deducciones: float
- sueldoBasico: float
- valorExtras: float
+ calcularSalario()
+ Planta() : void
+ getcargo() : var
+ getidentificacion() : var
+ getnombre() : var
+ getsalario() : var
+ getsueldoBasico() : var
+ getvalorExtras() : var
+ setdeducciones(var) : void
+ setsueldoBasico(var) : void
+ setvalorExtras(var) : void
Figura 5.1. Diagrama de clases del ejercicio.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
29SENA - Servicio Nacional de Aprendizaje.
5.2.2. Definición de la clase Empleado.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<?php
 class Empleado
 {
 protected $cargo;
 protected $identificacion;
 protected $nombre;
 protected $salario;
 
 public function Empleado($identificacion,$nombre,$cargo);
 {
 $this->identificacion=$identificacion;
 $this->nombre=$nombre;
 $this->cargo=$cargo;
 }
 protected function getCargo()
 {
 return $this->cargo;
 }
 protected function getIdentificacion()
 {
 return $this->identificacion;
 }
 protected function getNombre()
 {
 return $this->nombre;
 }
 protected function getSalario()
 {
 return $this->salario;
 }
 protected function setCargo($newVal)
 {
 $this->cargo = $newVal;
 }
 protected function setIdentificacion($newVal)
 {
 $this->identificacion = $newVal;
 }
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
30SENA - Servicio Nacional de Aprendizaje.
38
39
40
41
42
43
44
45
46
 }
 protected function setNombre($newVal)
 {
 $this->nombre = $newVal;
 }
 protected function setSalario($newVal)
 {
 $this->salario = $newVal;
 }
Figura 5.2. Clase Empleado.
5.2.3. Definición de la clase Contratista.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<?php
 class Contratista extends Empleado
 {
 private $totalHoras;
 private $valorHora;
 //Constructor
 public function
 Contratista($identificacion,$nombre,$cargo);
 {
 //Se ejecuta el constructor de la clase Padre Empleado
 parent::__construct($identificacion,$nombre,$cargo);
 }
 public function calcularSalario($totalHoras,$valorHora);
 {
 $this->salario= $valorHora*$totalHoras;
 }
 public function getTotalHoras()
 {
 return $this->totalHoras;
 }
 public function getValorHora()
 {
 return $this->ValorHora;
 }
 public function getCargo()
 {
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
31SENA - Servicio Nacional de Aprendizaje.
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 {
 return $this->cargo;
 }
 public function getIdentificacion()
 {
 return $this->identificacion;
 }
 public function getNombre()
 {
 return $this->nombre;
 }
 public function getSalario()
 {
 return $this->salario;
 }
 public function setTotalHoras($newVal)
 {
 $this->TotalHoras = $newVal;
 }
 public function setValorHora($newVal)
 {
 $this->ValorHora = $newVal;
 }
 }
?>
Figura 5.3. Clase Contratista.
5.2.4. Definición de la clase Planta.
1
2
3
4
5
6
7
8
9
10
11
<?php
class Planta extends Empleado
{
 private $deducciones;
 private $sueldoBasico;
 private $valorExtras;
 //Constructor
 public function Planta($identificacion,$nombre,$cargo)
 {
 //Se ejecuta el constructor de la clase Padre Empleado
 parent::__construct($identificacion,$nombre,$cargo);
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
32SENA - Servicio Nacional de Aprendizaje.
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 }
 public function calcularSalario()
 {
 $this->salario=$this->sueldoBasico + $this->valorExtras -
 $this->deducciones;
 }
 public function getDeducciones()
 {
 return $this->deducciones;
 }
 public function getSueldoBasico()
 {
 return $this->sueldoBasico;
 }
 public function getValorExtras()
 {
 return $this->valorExtras;
 }
 public function getCargo()
 {
 return $this->cargo;
 }
 public function getIdentificacion()
 {
 return $this->identificacion;
 }
 public function getNombre()
 {
 return $this->nombre;
 }
 public function getSalario()
 {
 return $this->salario;
 }
 public function setDeducciones($newVal)
 {
 $this->deducciones = $newVal;
 }
 public function setSueldoBasico($newVal)
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
33SENA - Servicio Nacional de Aprendizaje.
50
51
52
53
54
55
56
57
58
50
 public function setSueldoBasico($newVal)
 {
 $this->sueldoBasico = $newVal;
 }
 public function setValorExtras($newVal)
 {
 $this->valorExtras = $newVal;
 }
}
?>
Figura 5.4. Clase Planta.
Hasta el momento se definieron las clases Empleado, Contratista y Planta que componen 
el modelo de la aplicación.
5.2.5. Controlador de liquidación de empleados.
A continuación, se implementa el controlador para la liquidación de los empleados:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php
 include "empleado.php";
 include "planta.php";
 include "contratista.php";
 $tipo_empleado = $GET["tipo_empleado"];
 echo "tipo empleado es " . $tipo_empleado;
 if($tipo_empleado == 1 ){ // Planta
 
 $identificacion = ["identificacion"];
 $nombre = $_GET["nombre"];
 $cargo = $_GET["cargo"];
 
 $SueldoBasico = $_GET["sueldo_basico"];
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
34SENA - Servicio Nacional de Aprendizaje.
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 $SueldoBasico = $_GET["sueldo_basico"];
 $valorExtras = $_GET["horas_extras"];
 $deducciones = $_GET["deducciones"];
 
 $objPlanta = new Planta($identificacion,$nombre,$cargo);
 
 //se modifican los atributos del empleado de planta
 $objPlanta->setSueldoBasico($SueldoBasico);
 $objPlanta->setValorExtras($valorExtras);
 $objPlanta->setDeducciones($deducciones);
 $objPlanta->calcularSalario();
 echo "<table border=1 >";
 echo "<tr><td>Empleado ID:</td><td>" . 
$objPlanta->getIdentificacion() . "</td></tr>";
 echo"<tr><td>Nombre Empleado:</td><td> " . 
$objPlanta->getNombre(). "</td></tr>";
 echo "<tr><td>Cargo Empleado:</td><td> " . 
$objPlanta->getCargo(). "</td></tr>";
 echo "<tr><td>Sueldo Basico: </td><td>" . 
$objPlanta->getSueldoBasico(). "</td></tr>";
 echo "<tr><td>Valor Extras: </td><td>" . 
$objPlanta->getValorExtras(). "</td></tr>";
 echo "<tr><td>Total Deducciones: </td><td>" . 
$objPlanta->getDeducciones(). "</td></tr>";
 echo "<tr><td>Salario Neto a Recibir: </td><td>" . 
$objPlanta->getSalario(). "</td></tr>";
 echo "</table>";
 }
 if($tipo_empleado == 2 ){ // Contratista
 $identificacion = $_GET["identificacion"];
 $nombre = $_GET["nombre"];
 $cargo = $_GET["cargo"];
 
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
35SENA - Servicio Nacional de Aprendizaje.
53
54
55
56
57
58
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
67
68
69
70
71
72
73
74
 
 $valor_hora = $_GET["valor_hora"];
 $horas_trabajadas = $_GET["horas_trabajadas"];
 
 $objContratista = new Contratista($identificacion,
 $nombre,$cargo);
 $objContratista->setvalorHora($valor_hora);
 $objContratista->setTotalHoras($horas_trabajadas);
 $objContratista->calcularSalario($valor_hora,
 $horas_trabajadas);
 
 echo "<table border=1 >";
 echo "<tr><td>Empleado ID:</td><td>" . 
$objContratista->getIdentificacion() . "</td></tr>";
 echo "<tr><td>Nombre Empleado:</td><td> " . $objContratista
 ->getNombre()."</td></tr>";
 echo "<tr><td>Cargo Empleado:</td><td> " . $objContratista
 ->getCargo(). "</td></tr>";
 echo "<tr><td>Valor de la hora </td><td> " . 
$objContratista
 ->getValorHora() . "</td></tr>";
 echo "<tr><td>Número de horas </td><td> " . $objContratista
 ->getTotalHoras() . "</td></tr>";
 echo "<tr><td>Salario Neto a recibir en el Mes: </td><td>".
 $objContratista->getSalario() . "</td></tr>";
 echo "</table>";
 }
 
 
?>
Figura 5.5. Controlador liquidar_empleado.php
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
36SENA - Servicio Nacional de Aprendizaje.
Para la captura de la información se van a diseñar dos formularios HTML a través de 
clases así:
1. Formulario para empleados de planta:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<?php
 class FormularioPlanta {
 public function mostrar(){
 $html = <<<EOT
 <div class="container-fluid well">
 <div class="row clearfix">
 <form role="form" class="form-horizontal" 
 action="liquidar_empleado_planta.php">
 <div class="form-group">
 <label class="col-sm-3 
 control-label">Identificacion</label>
 <div class="col-sm-6">
 <input type="hidden" name="tipo_empleado" 
 value="1">
 <input type="text" class="form-control" 
 name="identificacion" 
 id="identificacion" 
 placeholder="Identificacion...">
 </div>
 </div>
 <div class="form-group">
 <label class="col-sm-3 
 control-label">Nombre</label>
 <div class="col-sm-6">
 <input type="text" class="form-control" 
 name="nombre" id="nombre" 
 placeholder="Nombre...">
 </div>
 </div>
 <div class="form-group">
 <label class="col-sm-3 
 control-label">Cargo</label>
 <div class="col-sm-6">
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
37SENA - Servicio Nacional de Aprendizaje.
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 <div class="col-sm-6">
 <input type="text" class="form-control" 
 name="cargo" id="cargo" 
 placeholder="Cargo...">
 </div>
 </div>
 <div class="form-group">
 <label class="col-sm-3 control-label">Sueldo 
 básico</label>
 <div class="col-sm-6">
 <input type="text" class="form-control" 
 name="sueldo_basico" id="sueldo_basico" 
 placeholder="Sueldo básico...">
 </div>
 </div>
 <div class="form-group">
 <label class="col-sm-3 control-label">Horas 
 Extras</label>
 <div class="col-sm-6">
 <input type="text" class="form-control" 
 name="horas_extras" id="horas_extras" 
 placeholder="Horas extras...">
 </div>
 </div>
 <div class="form-group">
 <label class="col-sm-3 
 control-label">Deducciones</label>
 <div class="col-sm-6">
 <input type="text" class="form-control" 
 name="deducciones" id="horas_extras" 
 placeholder="Deducciones...">
 </div>
 </div>
 <div class="form-group">
 <div class="col-sm-4 col-sm-offset-3">
 <input type="submit" class="btn btn-info" 
 value="Procesar">
 </div>
 </div> 
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
38SENA - Servicio Nacional de Aprendizaje.
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 </form>
 </div>
 </div>
EOT;
 echo $html ;
 }
 }
?> 
 }
}
?>
Figura 5.6. Clase FormularioPlanta.
2. Formulario para empleados contratistas:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?php
 class FormularioContratista {
 public function mostrar(){
 $html = <<<EOT
 <div class="container-fluid well">
 <div class="row clearfix">
 <form role="form" class="form-horizontal" 
 action="liquidar_empleado.php">
 <div class="form-group">
 <label class="col-sm-3 
 control-label">Identificacion</label>
 <div class="col-sm-6">
 <input type="hidden" name="tipo_empleado" 
 value="2">
 <input type="text" class="form-control" 
 name="identificacion" 
 id="identificacion" 
 placeholder="Identificacion...">
 </div>
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
39SENA - Servicio Nacional de Aprendizaje.
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
50
 placeholder="Identificacion...">
 </div>
 </div>
 <div class="form-group">
 <label class="col-sm-3 
 control-label">Nombre</label>
 <div class="col-sm-6">
 <input type="text" class="form-control" 
 name="nombre" id="nombre" 
 placeholder="Nombre...">
 </div>
 </div>
 <div class="form-group">
 <label class="col-sm-3 
 control-label">Cargo</label>
 <div class="col-sm-6">
 <input type="text" class="form-control" 
 name="cargo" id="cargo" 
 placeholder="Cargo...">
 </div>
 </div>
 <div class="form-group">
 <label class="col-sm-3 control-label">Valor 
 de la hora</label>
 <div class="col-sm-6">
 <input type="text" class="form-control" 
 name="valor_hora" id="valor_hora" 
 placeholder="Valor de la hora...">
 </div>
 </div>
 <div class="form-group">
 <label class="col-sm-3control-label">Horas 
 Trabajadas</label>
 <div class="col-sm-6">
 <input type="text" class="form-control" 
 name="horas_trabajadas" 
 id="horas_trabajadas" placeholder="Horas 
 extras...">
 </div>
 </div>
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
40SENA - Servicio Nacional de Aprendizaje.
59
60
61
62
63
64
65
67
68
69
70
71
72
 </form>
 </div>
 </div>
EOT;
 echo $html ;
 }
 }
?> 
 }
}
?>
Figura 5.7. Clase Formulario Contratista.
5.2.6. Definición de las vistas.
Una vez definidos los formularios como objetos se definen las vistas que los utilizan así:
1. Vista para los empleados de planta: 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<html>
 <head>
 <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/
 bootstrap/3.3.7/css/bootstrap.min.css">
 </head>
<body>
<?php
 include "empleado.php";
 include "planta.php";
 include "formularioPlanta.php";
 $formulario = new FormularioPlanta ;
 $formulario->mostrar(); 
?>
</body>
</html>
Figura 5.8. Vista para empleados de planta: vista_planta.php.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
41SENA - Servicio Nacional de Aprendizaje.
2. Vista para los empleados contratistas:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<html>
 <head>
 <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/
 bootstrap/3.3.7/css/bootstrap.min.css">
 </head>
<body>
<?php
 include "empleado.php";
 include "planta.php";
 include "fformularioContratista.php";
 $formulario = new formularioContratista ;
 $formulario->mostrar(); 
?>
</body>
</html>
Figura 5.9. Vista para empleados contratistas: vista_contratistas.php.
5.2.7. Ejecución de la aplicación.
1. Empleados de planta.
Para ejecutar la aplicación se llama primero la vista del empleado de planta (vista_planta.
php):
Figura 5.10. Ejecución vista para empleados de planta.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
42SENA - Servicio Nacional de Aprendizaje.
Al oprimir el botón de procesar aparece lo siguiente:
Figura 5.11. Resultado del ejemplo empleado de panta.
2. Empleados contratistas.
Para ejecutar la aplicación se llama primero la vista para los empleados contratistas 
(vista_contratista.php):
Figura 5.12. Ejecución vista empleado contratista.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
43SENA - Servicio Nacional de Aprendizaje.
Al oprimir el botón de procesar aparece lo siguiente:
Figura 5.13. Resultado del ejemplo de empleado contratista.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
44SENA - Servicio Nacional de Aprendizaje.
GLOSARIO
Apache: servidor web de amplio uso para alojar páginas web.
Atributo: característica o propiedad de una clase.
Clase: base de la POO que representa una entidad con atributos y métodos.
Constructor: método especial que se ejecuta cada vez que se crea un objeto.
CSS: acrónimo de Cascade-Style Sheet. Hojas de estilos en cascada.
Encapsulamiento: en POO es la propiedad que permite la visibilidad de algunos métodos 
y atributos sólo a ciertas clases.
Herencia: en POO es la propiedad que tienen las clases de transmitir de manera 
automática sus propiedades y métodos a otras clases.
HTML: acrónimo de HyperText Markup Languaje. Lenguaje de marcación de hipertextos.
HTTP: acrónimo de HyperText Transfer Protocol. Protocolo para el envío y recepción de 
páginas web.
Instancia: en POO es un sinónimo para objeto.
Interfaz: en POO Conjunto de nombres de métodos.
Javascript: lenguaje de programación que corre dentro de un navegador.
Librería: conjunto de archivos con programas que proveen servicios a las aplicaciones.
Método: función que define la forma como las clases se comportan.
MVC: acrónimo para el patrón de diseño Modelo-Vista-Controlador.
Objeto: es el resultado de la instanciación de una clase una vez se ejecuta el programa.
PDO: acrónimo de PHP Data Objects. Tecnología de PHP para conectarse a bases de 
datos.
Polimorfismo: en POO es la propiedad que tienen las clases de generar objetos distintos 
a partir de una misma interfaz.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
45SENA - Servicio Nacional de Aprendizaje.
PHP: acrónimo de PHP: Hypertext Preprocesor. Lenguaje de programación para internet.
POO: acrónimo de Programación Orientada a Objetos.
URL: acrónimo de Universal Resource Locator. Es el nombre técnico de las direcciones 
de las páginas en Internet.
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
46SENA - Servicio Nacional de Aprendizaje.
Cowburn, P. (2017). PHP Manual. Recuperado de http://php.net/manual/en/
Nixon, R. (2015). Learning PHP, MySQL & Javascript, Fourth Edition. Cambridge: 
O’reilly.
BIBLIOGRAFÍA
Programación orientada a objetos en php
FAVA - Formación en Ambientes Virtuales de Aprendizaje
47SENA - Servicio Nacional de Aprendizaje.
 
 
 
.
PROGRAMACIÓN ORIENTADA A OBJETOS EN PHP
Centro Industrial de Mantenimiento Integral - CIMI
Regional Santander
Claudia Milena Hernández Naranjo.
Tirso Fernán Tabares Carreño.
Rosa Elvia Quintero Guasca.
Santiago Lozada Garcés.
Francisco José Lizcano Reyes.
Víctor Hugo Tabares Carreño.
Líder línea de producción:
Asesores pedagógicos:
Rita Rubiela Rincón Badillo.
César Marino Cuéllar Chacón.(V1)
Líder expertos temáticos:
Experto temático:
Diseño multimedia:
Programador:
Producción de audio:
Nelson Mauricio Silva Maldonado. (V2)
 
 
k
 
 
Este material puede ser distribuido, copiado 
y exhibido por terceros si se muestra en los 
créditos. No se puede obtener ningún beneficio 
comercial y las obras derivadas tienen que estar 
bajo los mismos términos de la licencia que el 
trabajo original.
Copyright © 1997 - 2017 por el PHP Documentation 
Group.
Este material puede ser distribuido solamente 
sujeto a los términos y condiciones establecidos 
por la licencia de Creative Commons Attribution 
3.0 o superior. 
CONTROL DEL DOCUMENTO
Registered trademark
	CONTROL DEL DOCUMENTO
	BIBLIOGRAFÍA
	GLOSARIO
	5 ejercicio de ejemplo.
	5.1. Enunciado.
	5.2. Desarrollo del ejercicio.
	4. Usos prácticos de objetos.
	4.1. Acceso a bases de datos.
	4.2. Captura de los registros de una base de datos.
	2. Representación de las relaciones entre clases.
	2.1. Relación de dependencia.
	2.2. Relación de Agregación.
	2.3. Relación de Composición.
	1. Definición de clases. 
	1.1. Clases corrientes o regulares.
	1.2. Clases abstractas.
	1.5. Los atributos.
	1.6. Los constructores.
	1.7. Los métodos.
	1.8. Encapsulamiento.
	MAPA DE CONTENIDO
	INTRODUCCIÓN
	3. Los objetos.
	3.1. Ejemplo de construcción de objetos.
	3.2. Herencia.
	3.3. Ejecución de métodos.
	3.4. El operador de resolución de ámbito “::”.
	3.5. La palabra reservada “static”.
	3.6. La palabra reservada “self” y “parent”.
	3.7. Polimorfismo.