PROGRAMACIONnORIENTADAnAnOBJETOSnENnPHP 605f7e19f81c458 PDF

Programación
orientada
a objetos en
FAVA - Formación FAVA

en Ambientes
- Formación
Virtuales
en Ambientes
de Aprendizaje
Virtuales de Aprendizaje
SENA SENA
- Servicio
- Servicio
Nacional
Nacional
de Aprendizaje.
de Aprendizaje.
Programación orientada a objetos en php
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
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje. 2

Bibliografía...................................................................................................................... 46
Control del documento.................................................................................................... 47

PROGRAMACIÓN ORIENTADA A OBJETOS EN PHP
INTRODUCCIÓN
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”.

MAPA DE CONTENIDO
Programación
orientada
a objetos en
Elementos de
una Clase
Tipos de Clases
Clase
Clase final
normal
Clase Métodos
abstracta
qué son
Son los programas

o funciones incorporados
Atributos dentro de la clase tipos de
qué son
Modificadores Setters o
de acceso a los fijadores
atributos
Son las características o

propiedades de la clase Public Protected Destructor
Getters o
consultores
Private
Constructor

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 <?php
2 class NombreClase
3 {
4 // el código va aquí
5 }
6 ?>
7
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 <?php
2 abstract class NombreClase{
3 //No puede ser instanciada.
4 }
5 ?>
6
7
Figura 1.2. Definición de clases abstractas

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 <?php
2 final class NombreClase{
3 //Esta clase no permite ningún tipo de herencia
4 //No se puede hacer lo siguiente :
5 // class OtraClase extends claseFinal {
6 // este código genera un error.
7 // } ;
8 }
9 ?>
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 <?php
2 class NombreClase
3 {
4 //Definición de Atributos
5 //Definición Constructor
6 //Definición de destructor (opcional)
7 //Definición de Métodos
8 }
9 ?>
Figura 1.4. Estructura general de una clase.

A continuación se muestra la implementación de una clase denominada “Persona”.
1 <?php
2 class Persona
3 {
5 private $nombre;
6 //Constructor
7 public function Persona($nombre)
8 {
9 $this->nombre=$nombre;
10 }
12 public function getNombre()
13 {
14 return $this->nombre;
15 }
16 public function setNombre($value)
17 {
18 $this->nombre=$value;
19 }
20 public function leer($libro)
21 {
22 //aquí va el código del método
23 }
24 }
25 ?>
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.

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 <?php
2 class NombreClase{
4 private $identificación;
5 private $nombre;
6 private $fechanacimiento;
7 }
8 ?>
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”

1 <?php
3 //Constructor
4 public function __construct($nombre);
5 {
7 }
8 }
9 ?>
Figura 1.7. Ejemplo del constructor: __construct
2. Mediante un método llamado igual que el nombre de la clase.
1 <?php
2 class Persona{
3 //Constructor
4 public function Persona($nombre);
5 {
7 }
8 }
9 ?>
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.

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 <?php
5 {
7 }
9 {
11 }
12 }
13 ?>
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;

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 <?php
2 class Persona
3 {
5 private $value;
6 private $nombre;
8
9 //Constructor
10 public function Persona($nombre)
11 {
13 }
14
17 {
19 }
21 {
23 }
24 public function getIdentificación()
25 {
26 return $this->identificación;
27 }
28 public
SENA - Servicio function setidentificación($value)
Nacional de Aprendizaje. 12
29 {
23 }
24 public function getIdentificación()
25 {
Programación26
orientada a objetosreturn
en php $this->identificación;
27 }
28 public function setidentificación($value)

29 {
31 }
32 public function getFechaNacimiento()
33 {
34 return $this->fechaNacimiento;
35 }
36 public function setFechaNacimiento($value)
37 {
38 $this->fechaNacimiento=$value;
39 }
40 }
41 ?>
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 <?php
3 //Constructor
4 public Atributo;
5 {
6 return $valor;
7 }
8 }
9 ?>
Figura 1.11. Ejemplo de un método público.

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 <?php
4 private $identificación;
5 private $Nombre;
7
9 private function operacion($valor1)
10 {
11 return $valor*2;
12 }
13 }
14 ?>
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 <?php
4 protected $identificación;
5 protected $Nombre;
6 }
7 ?>
Figura 1.13. Ejemplo de un método “protected”.

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
Carro Motor
- cilindraje
+ mostrarMotor(Motor):void
+ getCilindraje() : var
+ Motor(var) : void
Figura 2.1 Modelo de clases con relación de dependencia.

En php se implementa así:
1 <?php
2 require_once ('Motor.php');
3 class Carro
4 {
5 function mostrarMotor(Motor $objetoMotor)
6 {
7 echo $objetoMotor->getCilindraje();
8 }
9 }
10 ?>
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.

Curso Aprendices
- aprendices: array
+ mostrarMotor(Motor):void
Figura 2.3. Modelo de clases con agregación.
En php se implementa así:
1 <?php
2 require_once (Aprendices.php');
3
4 class Curso
5 {
6 //Se define un arreglo donde se van a guardar los aprendices
7 private $aprendices = array();
8
9 function agregarAprendices(Aprendices $aprendiz)
10 {
11 //se agrega al arreglo $aprendices el objeto aprendiz
12 this->aprendices[] = $aprendiz;
13 }
14 }
15
16 $objCurso = new Curso();
17 $objCurso->agregarAprendices(new Aprendices());
22
23 /* Como ejemplo en el curso anterior solo se agregaron 5 aprendices */
24 ?>
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:

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:

1 <!DOCTYPE html>
2 <html>
3 <body>
4 <?php
5 //se incluye el archivo donde esta el código de la
6 clase Persona
7 include “Persona.php”;
8
9 //Se instancia el primer Objeto
10 $objPersona=new Persona(“Pedro Picapiedra”);
11 //Instanciamos
12
13 /* Para poder mostrar en pantalla el nombre de la
14 persona se debe utilizar el método gerNombre(), ya que
15 el atributo $nombre es privado.*/
16 //Ahora se instancia otra vez la clase persona
17
18 $objPersona=new Persona(“Vilma”);
19 echo “<br> Nombre del segundo obeto Persona : ”.
20 $objPersona->getNombre();
21
22 ?>
23 </body>
24 </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 Esta línea crea un objeto llamado $objPersona y se está
Persona(“Pedro Picapiedra”) pasando como parámetro el valor de “Pedro Picapiedra”.
echo “<br> En esta línea se obtiene el nombre de la persona
Nombre del Primer obeto mediante el método getNombre() de la clase persona y
Persona: lo imprime en pantalla.
” . $ o b j P e r s o n a -
>getNombre(); Se debe utilizar ese método debido a que el atributo
Nombre está definido como private.
?> Etiqueta de cierre del código php.

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 <?php
2 include “Persona.php”;//Se incluye para poder acceder
3 a ella
4 class Estudiante extends Persona
5 {
6 //Atributo curso: Que curso estudia el Estudiante.
7 private $curso;
8 //Método que obtiene el curso que estudia el
9 estudiante.
10 public function getCurso()
11 {
12 return $this->curso;
13FAVA - Formación
} en Ambientes Virtuales de Aprendizaje
14 SENA - Servicio Nacional de Aprendizaje. 19
15 //Método que permite cambiar el curso del
16 estudiante.
4 class Estudiante extends Persona
5 {
6 //Atributo curso: Que curso estudia el Estudiante.
7 private $curso;
8 //Método que obtiene el curso que estudia el
9 estudiante.
10 public function getCurso()
11 {
12 return $this->curso;
13 }
14
15 //Método que permite cambiar el curso del
16 estudiante.
17 public function setCurso($value)
18 {
19 $this->curso=$value;
20 }
21
22 //Constructor Clase Estudiante
23 public function Estudiante($nombre, $curso)
24 {
27 $this->curso=$curso;
28 }
29 }
30 ?>
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 <?php
2 //Se incluye el archivo donde está el
3 código de la clase Persona
4 include Estudiante.php”;
5 //Se instancia para crear el primer
6 objeto tipo Estudiante
7 $ObjEstudiante=new Estudiante($nombre,$curso)
8 ?>
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”.

1 <html>
2 <body>
3 <?php
4 //Se incluye el archivo donde está el código de la clase Persona
5 include "Estudiante.php";
6
7 //Se instancia el primer objeto tipo Estudiante
8 $objEstudiante=new Estudiante("César Cuéllar", "ADSI");
9
10 //Se crea otro objeto de tipo Estudiante
11 $objEstudiante2=new Estudiante2("Marcela Méndez", "Multimedia");
12 echo "ESTUDIANTES INSCRITOS<BR>";
13
14 /*Se muestra por pantalla los datos de los estudiantes
15 Se accede al método getNombre() que lo hereda de la clase persona*/
16 echo "<br> Nombre del Estudiante : ". $objEstudiante->getNombre();
17
18 /*Ahora se va a imprimir en pantalla el Curso, para ello
19 se accede al método getCurso() propio de la clase Estudiante.*/
20
21 echo "<br> Curso que se encuentra el Estudiante : ". $objEstudiante->getNombre();
22 echo "<br> Nombre del Estudiante : ". $objEstudiante2->getNombre();
23 echo "<br> Curso que se encuentra el Estudiante : ". $objEstudiante2->getNombre();
24 ?>
26 </body>
27 </html>
Figura 3.5. Ejemplo completo de herencia.
Resultado de la Implementación:
Figura 3.6. Resultado del ejemplo de herencia.

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 <html>
2 <body>
3 <?php
4 class mi_clase {
5 const MI_CONSTANTE = 'Valor constante';
6 }
7
8 echo mi_clase::MI_CONSTANTE ;
9 ?>
10 </body>
11 </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.

1 <html>
2 <body>
3 <?php
4 class mi_clase {
5 public static function mi_metodo_estatico(){
6 echo "soy un método estático";
7 }
8 }
9
10 echo mi_clase::mi_metodo_estatico() ;
11 ?>
12 </body>
13 </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 <html>
2 <body>
3 <?php
4 class mi_clase {
5 public static function mi_metodo_estatico(){
6 echo 'soy un método estático';
7 }
8 }
9
10 class mi_clase_hija extends mi_clase {
11
12 public static $variable_estatica = 'soy una variable estática';
13
14 public static function mi_metodo_hijo() {
15 echo parent::mi_metodo_estatico()."<br>";
16 echo self::$variable_estatica;
17
18 }
19 }
20
21 echo mi_clase::mi_metodo_estatico()."<br>" ;
22 echo mi_clase_hija::mi_metodo_hijo();
23 ?>
24
26 </body>
27 </html>
Figura 3.9. Ejemplo de uso de “parent” y “self”.

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 <?php
2 abstract class moneda {
3 abstract public function convertir_a_pesos($cantidad);
4 }
5 }
6
7 class Dolar extends moneda {
8 public function convertir_a_pesos($cantidad){
9 return $cantidad * 3000 ;
10 }
11 }
12
13 class Euro extends moneda {
16 }
17 }
18
19 $dolar = new Dolar ;
20 echo $dolar->convertir_a_pesos(100) . "<br>";
21
22 $euro = new Euro ;
23 echo $euro->convertir_a_pesos(100);
24 ?>
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.

El anterior ejemplo se puede implementar haciendo uso de la palabra reservada “interface”

así:
1 <?php
2 Interface moneda {
3 public function convertir_a_pesos($cantidad);
4 }
5 }
6
7 class Dolar implements moneda {
10 }
11 }
12
13 class Euro extends moneda {
16 }
17 }
18
19 $dolar = new Dolar ;
20 echo $dolar*convertir_a_pesos(100) . "<br>";
21
22 $euro = new Euro ;
23 echo $euro*convertir_a_pesos(100);
24 ?>
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”:

1 <?php
2 $conn = new mysqli("localhost", "desarrollador",
3 "adsi2017", "citas" ) ;
4 if( $conn->connect_errno) {
5 echo "Falla al conectarse a Mysql
6 ( ". $conn->connect_errno . ") " .
7 $conn->connect_error ;
8 } else {
9 echo $conn->host_info. "\n" ;
10 } ;
11 ?>
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 <?php
2 if( $resultado = $conn->query(("select codigo, nombre from ciudades ") ) {
3 while($registro = $resultado->fetch_object() ){
4 echo $registro->codigo . " " . $registro->nombre . "\n" ;
5
6 } else {
7 echo $conn->host_info. "\n" ;
8 } ;
9 ?>
Figura 4.2. Ejemplo de registro implementado en un objeto.

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 de aprendizaje: “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>

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 Planta
- totalHoras: int - deducciones: float

- valorHora: float - sueldoBasico: float
- valorExtras: float
+ CalcularSalario(var,var) + calcularSalario()
+ Contratista() : void + Planta() : void
+ getcargo() : var + getcargo() : var

+ getidentificacion() : var + getidentificacion() : var
+ getnombre() : var + getnombre() : var
+ getsalario() : var + getsalario() : var
+ gettotalHoras() : var + getsueldoBasico() : var
+ getvalorHoras() : var + getvalorExtras() : var
+ settotal(var) : void + setdeducciones(var) : void

+ setvalorHoras(var) : void + setsueldoBasico(var) : void
+ setvalorExtras(var) : void
Figura 5.1. Diagrama de clases del ejercicio.

5.2.2. Definición de la clase Empleado.
1 <?php
2 class Empleado
3 {
4 protected $cargo;
5 protected $identificacion;
6 protected $nombre;
7 protected $salario;
8
9 public function Empleado($identificacion,$nombre,$cargo);
10 {
11 $this->identificacion=$identificacion;
13 $this->cargo=$cargo;
14 }
15 protected function getCargo()
16 {
17 return $this->cargo;
18 }
19 protected function getIdentificacion()
20 {
21 return $this->identificacion;
22 }
23 protected function getNombre()
24 {
26 }
27 protected function getSalario()
28 {
29 return $this->salario;
30 }
31 protected function setCargo($newVal)
32 {
33 $this->cargo = $newVal;
34 }
35 protected function setIdentificacion($newVal)
36 {
37 $this->identificacion = $newVal;
38 }
39 protected function setNombre($newVal)
40 FAVA - Formación
{ en Ambientes Virtuales de Aprendizaje
41 $this->nombre = $newVal;
42 }
43 protected function setSalario($newVal)
32 {
33 $this->cargo = $newVal;
34 }
35 orientadaprotected
Programación function
a objetos en php setIdentificacion($newVal)
36 {
37 $this->identificacion = $newVal;
38 }
39 protected function setNombre($newVal)
40 {
41 $this->nombre = $newVal;
42 }
43 protected function setSalario($newVal)
44 {
45 $this->salario = $newVal;
46 }
47 } Figura 5.2. Clase Empleado.
48 ?>
5.2.3. Definición de la clase Contratista.
1 <?php
2 class Contratista extends Empleado
3 {
4 private $totalHoras;
5 private $valorHora;
6 //Constructor
7 public function
8 Contratista($identificacion,$nombre,$cargo);
9 {
10 //Se ejecuta el constructor de la clase Padre Empleado
11 parent::__construct($identificacion,$nombre,$cargo);
12 }
13 public function calcularSalario($totalHoras,$valorHora);
14 {
15 $this->salario= $valorHora*$totalHoras;
16 }
17 public function getTotalHoras()
18 {
19 return $this->totalHoras;
20 }
21 public function getValorHora()
22 {
23 return $this->ValorHora;
24 }
25 public function getCargo()
26 {
28 }
29 FAVA - Formación
public function
en AmbientesgetIdentificacion()
Virtuales de Aprendizaje
30 { SENA - Servicio Nacional de Aprendizaje. 30
32 }
20 }
21 public function getValorHora()
22 {
23 return $this->ValorHora;
24 }
26 {
28 }
29 public function getIdentificacion()
30 {
32 }
34 {
36 }
37 public function getSalario()
38 {
40 }
41 public function setTotalHoras($newVal)
42 {
43 $this->TotalHoras = $newVal;
44 }
45 public function setValorHora($newVal)
46 {
47 $this->ValorHora = $newVal;
48 }
49 }
50 ?>
Figura 5.3. Clase Contratista.
5.2.4. Definición de la clase Planta.
1 <?php
2 class Planta extends Empleado
3 {
4 private $deducciones;
5 private $sueldoBasico;
6 private $valorExtras;
7 //Constructor
8 public function Planta($identificacion,$nombre,$cargo)
9 {
12 }
13 public function calcularSalario()
14
{
15 $this->salario=$this->sueldoBasico + $this->valorExtras -
5 private $sueldoBasico;
6 private $valorExtras;
7 //Constructor
8 public function Planta($identificacion,$nombre,$cargo)
9 {
12 }
13 public function calcularSalario()
14 {
15 $this->salario=$this->sueldoBasico + $this->valorExtras -
16 $this->deducciones;
17 }
18 public function getDeducciones()
19 {
20 return $this->deducciones;
21 }
22 public function getSueldoBasico()
23 {
24 return $this->sueldoBasico;
25 }
26 public function getValorExtras()
27 {
28 return $this->valorExtras;
29 }
31 {
33 }
34 public function getIdentificacion()
35 {
37 }
39 {
41 }
42 public function getSalario()
43 {
45 }
46 public function setDeducciones($newVal)
47 {
48 $this->deducciones = $newVal;
49 }
50 public function setSueldoBasico($newVal)
51 {
52 $this->sueldoBasico = $newVal;
53 }
54 public function setValorExtras($newVal)
55 {
45 }
46 public function setDeducciones($newVal)
47 {
48 $this->deducciones = $newVal;
49 }
50 public function setSueldoBasico($newVal)
51 {
52 $this->sueldoBasico = $newVal;
53 }
54 public function setValorExtras($newVal)
55 {
56 $this->valorExtras = $newVal;
57 }
58 }
50 ?>
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 <?php
2 include "empleado.php";
3 include "planta.php";
4 include "contratista.php";
5 $tipo_empleado = $GET["tipo_empleado"];
6 echo "tipo empleado es " . $tipo_empleado;
7
8 if($tipo_empleado == 1 ){ // Planta
9
10
11 $identificacion = ["identificacion"];
12 $nombre = $_GET["nombre"];
13 $cargo = $_GET["cargo"];
14
15 $SueldoBasico = $_GET["sueldo_basico"];
16 $valorExtras = $_GET["horas_extras"];
17 $deducciones = $_GET["deducciones"];
18
19 $objPlanta = new Planta($identificacion,$nombre,$cargo);
20
21 //se modifican los atributos del empleado de planta
22 $objPlanta->setSueldoBasico($SueldoBasico);
23 FAVA$objPlanta->setValorExtras($valorExtras);
- Formación en Ambientes Virtuales de Aprendizaje
24 $objPlanta->setDeducciones($deducciones); 33
SENA - Servicio Nacional de Aprendizaje.
25
26
8 if($tipo_empleado == 1 ){ // Planta
9
10
11 $identificacion = ["identificacion"];
14
15 $SueldoBasico = $_GET["sueldo_basico"];
16 $valorExtras = $_GET["horas_extras"];
17 $deducciones = $_GET["deducciones"];
18
19 $objPlanta = new Planta($identificacion,$nombre,$cargo);
20
21 //se modifican los atributos del empleado de planta
22 $objPlanta->setSueldoBasico($SueldoBasico);
23 $objPlanta->setValorExtras($valorExtras);
24 $objPlanta->setDeducciones($deducciones);
25
26
27 $objPlanta->calcularSalario();
28
29 echo "<table border=1 >";
30 echo "<tr><td>Empleado ID:</td><td>" .
31 $objPlanta->getIdentificacion() . "</td></tr>";
32 echo "<tr><td>Nombre Empleado:</td><td> " .
33 $objPlanta->getNombre(). "</td></tr>";
34 echo "<tr><td>Cargo Empleado:</td><td> " .
35 $objPlanta->getCargo(). "</td></tr>";
36 echo "<tr><td>Sueldo Basico: </td><td>" .
37 $objPlanta->getSueldoBasico(). "</td></tr>";
38 echo "<tr><td>Valor Extras: </td><td>" .
39 $objPlanta->getValorExtras(). "</td></tr>";
40 echo "<tr><td>Total Deducciones: </td><td>" .
41 $objPlanta->getDeducciones(). "</td></tr>";
42 echo "<tr><td>Salario Neto a Recibir: </td><td>" .
43 $objPlanta->getSalario(). "</td></tr>";
44 echo "</table>";
45 }
46
47 if($tipo_empleado == 2 ){ // Contratista
48
49 $identificacion = $_GET["identificacion"];
52
53 $valor_hora = $_GET["valor_hora"];
54 $horas_trabajadas = $_GET["horas_trabajadas"];
55
56
57 $objContratista = new Contratista($identificacion,
58 $nombre,$cargo);
46
47 if($tipo_empleado == 2 ){ // Contratista
48
49 $identificacion = $_GET["identificacion"];
52
53 $valor_hora = $_GET["valor_hora"];
54 $horas_trabajadas = $_GET["horas_trabajadas"];
55
56
57 $objContratista = new Contratista($identificacion,
58 $nombre,$cargo);
50 $objContratista->setvalorHora($valor_hora);
51 $objContratista->setTotalHoras($horas_trabajadas);
52 $objContratista->calcularSalario($valor_hora,
53 $horas_trabajadas);
54
55 echo "<table border=1 >";
56 echo "<tr><td>Empleado ID:</td><td>" .
57 $objContratista->getIdentificacion() . "</td></tr>";
58 echo "<tr><td>Nombre Empleado:</td><td> " . $objContratista
59 ->getNombre()."</td></tr>";
60 echo "<tr><td>Cargo Empleado:</td><td> " . $objContratista
61 ->getCargo(). "</td></tr>";
62 echo "<tr><td>Valor de la hora </td><td> " .
63 $objContratista
64 ->getValorHora() . "</td></tr>";
65 echo "<tr><td>Número de horas </td><td> " . $objContratista
67 ->getTotalHoras() . "</td></tr>";
68 echo "<tr><td>Salario Neto a recibir en el Mes: </td><td>".
69 $objContratista->getSalario() . "</td></tr>";
70 echo "</table>";
71 }
72
73
74 ?>
Figura 5.5. Controlador liquidar_empleado.php

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 <?php
2 class FormularioPlanta {
3
4 public function mostrar(){
5 $html = <<<EOT
6 <div class="container-fluid well">
7 <div class="row clearfix">
8 <form role="form" class="form-horizontal"
9 action="liquidar_empleado_planta.php">
10
11 <div class="form-group">
12 <label class="col-sm-3
13 control-label">Identificacion</label>
14 <div class="col-sm-6">
15 <input type="hidden" name="tipo_empleado"
16 value="1">
17 <input type="text" class="form-control"
18 name="identificacion"
19 id="identificacion"
20 placeholder="Identificacion...">
21 </div>
22 </div>
25 control-label">Nombre</label>
28 name="nombre" id="nombre"
29 placeholder="Nombre...">
30 </div>
31 </div>
34 control-label">Cargo</label>
37 name="cargo" id="cargo"
38 placeholder="Cargo...">
39 </div>
30 </div>
31 </div>
39 </div>
40 </div>
42 <label class="col-sm-3 control-label">Sueldo
43 básico</label>
46 name="sueldo_basico" id="sueldo_basico"
47 placeholder="Sueldo básico...">
48 </div>
49 </div>
51 <label class="col-sm-3 control-label">Horas
52 Extras</label>
55 name="horas_extras" id="horas_extras"
56 placeholder="Horas extras...">
57 </div>
58 </div>
52 control-label">Deducciones</label>
55 name="deducciones" id="horas_extras"
56 placeholder="Deducciones...">
57 </div>
58 </div>
59
61 <div class="col-sm-4 col-sm-offset-3">
62 <input type="submit" class="btn btn-info"
63 value="Procesar">
64 </div>
65 </div>
67
68
69 </form>
70 </div>
59
64 </div>
65 </div>
67
68
69 </form>
70 </div>
71 </div>
72 EOT;
73 echo $html ;
74 }
75 }
76 ?>
77
78 }
79 }
80 ?>
Figura 5.6. Clase FormularioPlanta.
2. Formulario para empleados contratistas:
1 <?php
2 class FormularioContratista {
3
4 public function mostrar(){
5 $html = <<<EOT
6 <div class="container-fluid well">
7 <div class="row clearfix">
8 <form role="form" class="form-horizontal"
9 action="liquidar_empleado.php">
10
13 control-label">Identificacion</label>
16 value="2">
21 </div>
22 FAVA - Formación en Ambientes
</div>Virtuales de Aprendizaje
23 <divNacional
SENA - Servicio class="form-group">
de Aprendizaje. 38
16 value="2">
21 </div>
22 </div>
30 </div>
31 </div>
39 </div>
40 </div>
42 <label class="col-sm-3 control-label">Valor
43 de la hora</label>
46 name="valor_hora" id="valor_hora"
47 placeholder="Valor de la hora...">
48 </div>
49 </div>
51 <label class="col-sm-3 control-label">Horas
52 Trabajadas</label>
55 name="horas_trabajadas"
56 id="horas_trabajadas" placeholder="Horas
57 extras...">
58 </div>
50 </div>
51 FAVA - Formación en Ambientes Virtuales de Aprendizaje
52 <div
SENA - Servicio class="form-group">
Nacional de Aprendizaje. 39
56 </div>
57 </div>
58
59
60 </form>
61 </div>
62 </div>
63 EOT;
64 echo $html ;
65 }
67 }
68 ?>
69
70 }
71 }
72 ?>
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 <html>
2 <head>
3 <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/
4 bootstrap/3.3.7/css/bootstrap.min.css">
5 </head>
6 <body>
7 <?php
10 include "formularioPlanta.php";
11 $formulario = new FormularioPlanta ;
12 $formulario->mostrar();
13 ?>
14 </body>
15 </html>
Figura 5.8. Vista para empleados de planta: vista_planta.php.

2. Vista para los empleados contratistas:
1 <html>
2 <head>
3 <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/
4 bootstrap/3.3.7/css/bootstrap.min.css">
5 </head>
6 <body>
7 <?php
10 include "fformularioContratista.php";
11 $formulario = new formularioContratista ;
12 $formulario->mostrar();
13 ?>
14 </body>
15 </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.

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.

Al oprimir el botón de procesar aparece lo siguiente:
Figura 5.13. Resultado del ejemplo de empleado contratista.

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.

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.

BIBLIOGRAFÍA
Cowburn, P. (2017). PHP Manual. Recuperado de http://php.net/manual/en/
Nixon, R. (2015). Learning PHP, MySQL & Javascript, Fourth Edition. Cambridge:
O’reilly.

CONTROL DEL DOCUMENTO
PROGRAMACIÓN ORIENTADA A OBJETOS EN PHP
Centro Industrial de Mantenimiento Integral - CIMI

Regional Santander
Líder línea de producción:Santiago Lozada Garcés.
Rosa Elvia Quintero Guasca.

Asesores pedagógicos:
Claudia Milena Hernández Naranjo.
Líder expertos temáticos: Rita Rubiela Rincón Badillo.
Experto temático: César Marino Cuéllar Chacón.(V1)
Nelson Mauricio Silva Maldonado. (V2)
Diseño multimedia: Tirso Fernán Tabares Carreño.
Programador: Francisco José Lizcano Reyes.
Producción de audio: Víctor Hugo Tabares Carreño.
Este material puede ser distribuido, copiado Copyright © 1997 - 2017 por el PHP Documentation
y exhibido por terceros si se muestra en los Group.
créditos. No se puede obtener ningún beneficio Este material puede ser distribuido solamente
comercial y las obras derivadas tienen que estar sujeto a los términos y condiciones establecidos
bajo los mismos términos de la licencia que el por la licencia de Creative Commons Attribution
trabajo original. 3.0 o superior.
Registered trademark
.
k

PROGRAMACIONnORIENTADAnAnOBJETOSnENnPHP 605f7e19f81c458 PDF

Cargado por

Copyright:

Formatos disponibles

PROGRAMACIONnORIENTADAnAnOBJETOSnENnPHP 605f7e19f81c458 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

PROGRAMACIONnORIENTADAnAnOBJETOSnENnPHP 605f7e19f81c458 PDF

Cargado por

Copyright:

Formatos disponibles

Programación

FAVA - Formación FAVA

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 2

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 3

PROGRAMACIÓN ORIENTADA A OBJETOS EN PHP

En el desarrollo de sistemas de información el paradigma de la programación orientada

En este recurso se presentarán los fundamentos de programación orientada a objetos

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 4

Son los programas

Son las características o

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 5

Dependiendo de su tipo las clases pueden ser:

1.1. Clases corrientes o regulares.

1.2. Clases abstractas.

Figura 1.2. Definición de clases abstractas

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 6

1.3. Definición de una clase final

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

Figura 1.4. Estructura general de una clase.

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 7

A continuación se muestra la implementación de una clase denominada “Persona”.

Figura 1.5. Ejemplo de definición de una clase.

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 8

1.5. Los atributos.

A continuación un ejemplo de definición de métodos privados.

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

Se pueden definir varios constructores (sobrecarga de constructores) que permitan crear

Se pueden definir de dos formas:

1. Mediante un método llamado “__construct”

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 9

Figura 1.7. Ejemplo del constructor: __construct

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

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

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 10

1.7. Los métodos.

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

Los atributos de un objeto se modifican mediante llamadas a sus métodos. A continuación

Figura 1.9. Ejemplo de definición de métodos

Este tipo de métodos se conocen como “getters”. Se acostumbra a incluir en el nombre

El segundo método recibe un parámetro y este parámetro es asignado al atributo nombre:

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 11

Este tipo de métodos se conocen como “setters”. Se acostumbra a incluir en el nombre

El encapsulamiento se da cuando los atributos de una clase no pueden ser modificados