Desarrollo de Aplicaciones

en Internet

Laboratorio N° 04

OOP con PHP

Parte I
CÓDIGO DEL CURSO: II3100

Alumno(s) Nota

Grupo

Ciclo III

Fecha
 Laboratorio 04 - OOP con PHP
Página 1

I. OBJETIVOS

○ Aprender a trabajar con programación orientada a objetos usando PHP.

II. SEGURIDAD

Advertencia:
En este laboratorio está prohibida la manipulación de hardware, conexiones
eléctricas o de red; así como la ingestión de alimentos o bebidas.

III. NORMAS EMPLEADAS

○ No aplica

IV. RECURSOS
○ En el siguiente laboratorio se trabajará con un equipo que cuente con una conexión a
Internet y una navegador web (Mozilla Firefox o Google Chrome)
○ XAMPP instalado o una máquina virtual de Windows con XAMPP en VMWare Player
(mínimo versión 14).

V. METODOLOGÍA PARA EL DESARROLLO DE LA TAREA

○ El desarrollo del laboratorio es individual.
 Laboratorio 04 - OOP con PHP
Página 2

VI. PROCEDIMIENTO

A. Estándares y Recomendaciones

1. Indague sobre PSR (PHP Standards Recommendations) y mencione todas las

consideraciones y sugerencias al momento de definir clases y/o instanciar objetos dentro
de PHP.
Las PSR ofrecen una guía valiosa para la definición de clases y la instanciación de
objetos en PHP. Seguir estas recomendaciones puede mejorar significativamente la
calidad, la mantenibilidad y la interoperabilidad del código PHP.

B. Definición de Clases y Objetos

2. PHP soporta conceptos de programación orientada a objetos como clases, objetos,

herencia, encapsulación y polimorfismo.

3. Ejemplo de una clase en PHP. Tiene una definición, propiedades, constructor y una
función.
 Laboratorio 04 - OOP con PHP
Página 3

4. Cree una clase Estudiante, con atributos nombre, curso y nota. No olvide probar la clase
instanciando un objeto.

<?php
class Estudiante {
private $nombre;
private $curso;
private $nota;
public function __construct($nombre, $curso, $nota) {
$this->nombre = $nombre;
$this->curso = $curso;
$this->nota = $nota;
}
public function getNombre() {
return $this->nombre;
}
public function setNombre($nombre) {
$this->nombre = $nombre;
}
public function getCurso() {
return $this->curso;
}
public function setCurso($curso) {
$this->curso = $curso;
}
public function getNota() {
return $this->nota;
}
public function setNota($nota) {
$this->nota = $nota;
}
public function __toString() {
return "Estudiante: " . $this->nombre . "\nCurso: " . $this->curso .
"\nNota: " . $this->nota;
}
}
$estudiante1 = new Estudiante("Ana", "Matemáticas", 10);
echo $estudiante1 . "\n";
$estudiante2 = new Estudiante("Juan", "Física", 8);
$estudiante2->setNombre("Pedro");
echo $estudiante2;
?>

5. También podemos definir nuestra propia clase para vectores (arrays).

 Laboratorio 04 - OOP con PHP
Página 4

<?php

class SimpleArray {
private $elements = [];

// Constructor to initialize the array with provided elements

public function __construct($elements = []) {
$this->elements = $elements;
}

// Method to add an element to the array

public function add($element) {
$this->elements[] = $element;
}

// Method to remove an element from the array by value

public function remove($element) {
$index = array_search($element, $this->elements);
if ($index !== false) {
unset($this->elements[$index]);
}
}

// Method to check if an element exists in the array

public function contains($element) {
return in_array($element, $this->elements);
}

// Method to get the size of the array

public function size() {
return count($this->elements);
}

// Method to get all elements of the array

public function getAll() {
return $this->elements;
}
}

6. Podríamos hacer uso de la clase anterior de la siguiente forma:

// Example usage:
$array = new SimpleArray([1, 2, 3, 4, 5]);

$array->add(6);
$array->remove(3);

echo "Element 2 exists?: " . ($array->contains(2) ? "Yes" : "No") . "<br />";

echo "Array size: " . $array->size() . "<br />";
 Laboratorio 04 - OOP con PHP
Página 5

echo "All elements in array: " . implode(", ", $array->getAll()) . "<br />";

7. Genere una clase que permita la definición de árbol binario simple que solo tenga la
capacidad de agregar nodos.
8. <?php
9. class SimpleBinaryTree {
10. private $root;
11.
12. public function __construct() {
13. $this->root = null;
14. }
15.
16. public function addNode($data) {
17. $newNode = new Node($data);
18.
19. if ($this->root === null) {
20. $this->root = $newNode;
21. return;
22. }
23.
24. $currentNode = $this->root;
25. while (true) {
26. if ($data <= $currentNode->data) {
27. if ($currentNode->left === null) {
28. $currentNode->left = $newNode;
29. return;
30. }
31. $currentNode = $currentNode->left;
32. } else {
33. if ($currentNode->right === null) {
34. $currentNode->right = $newNode;
35. return;
36. }
37. $currentNode = $currentNode->right;
38. }
39. }
40. }
41. }
42. class Node {
43. public $data;
44. public $left;
45. public $right;
46. public function __construct($data) {
47. $this->data = $data;
48. $this->left = null;
49. $this->right = null;
50. }
 Laboratorio 04 - OOP con PHP
Página 6

51. }
52. ?>

C. Encapsulación

1. La encapsulación nos permite compactar el objeto o clase con sus métodos, no sólo tiene
el constructor sino también funciones que nos permiten asignar valor a propiedades (Set) y
también devolver (Get) las propiedades una por una. La Encapsulación es bastante usada
en la programación orientada objetos, porque permite al objeto ser reutilizado.
<?php

class Coche {
// Propiedades
private $modelo;
private $color;
private $precio;

// Constructor
public function __construct($modelo, $color, $precio) {
$this->modelo = $modelo;
$this->color = $color;
$this->precio = $precio;
}

// Métodos de obtención (getters)

public function getModelo() {
return $this->modelo;
}

public function getColor() {

return $this->color;
}

public function getPrecio() {

return $this->precio;
}

// Métodos de asignación (setters)

public function setColor($color) {
$this->color = $color;
}

public function setPrecio($precio) {

$this->precio = $precio;
}
}
 Laboratorio 04 - OOP con PHP
Página 7

2. Podríamos hacer uso de la clase anterior de la siguiente forma:

// Crear un objeto de la clase Coche
$coche = new Coche("Toyota", "Azul", 20000);

// Acceder a las propiedades usando los métodos de obtención

echo "Modelo: " . $coche->getModelo() . "<br>"; // Salida: Modelo: Toyota
echo "Color: " . $coche->getColor() . "<br>"; // Salida: Color: Azul
echo "Precio: $" . $coche->getPrecio() . "<br>"; // Salida: Precio: $20000

3. Valide su clase definida para el árbol binario procurando que cumpla con el principio de
encapsulamiento. Proponga cambios o justifique cómo es que su clase cumple con dicho
principio:
1. Análisis de la clase Coche:
La clase Coche cumple con el principio de encapsulación de la siguiente manera:
• Atributos privados: Los atributos modelo, color y precio son declarados
como private, lo que significa que solo son accesibles dentro de la clase.
• Métodos de acceso (getters y setters): Se proporcionan métodos
públicos getModelo(), getColor(), getPrecio(), setColor() y setPrecio() para
acceder y modificar los valores de los atributos privados.
2. Aplicación del encapsulamiento en la clase Árbol Binario:
Para validar la encapsulación en la clase Árbol Binario, se debe analizar si cumple
con los siguientes aspectos:
a) Atributos:
• Los atributos que representan la estructura del árbol (nodo raíz, nodos hijos, etc.)
deberían ser privados.
• Se pueden considerar atributos públicos para almacenar información adicional del
árbol, como el tamaño o la altura, si es necesario que sean accesibles desde
otras clases.
b) Métodos:
• Se deben proporcionar métodos públicos para:
o Acceder a los atributos públicos: Estos métodos no deberían modificar
el estado del árbol.
o Realizar operaciones sobre el árbol: Insertar nodos, eliminar nodos,
buscar nodos, recorrer el árbol, etc. Estos métodos pueden modificar el
estado del árbol.
• Los métodos que modifican el estado del árbol deberían realizar las
validaciones necesarias para garantizar la integridad del árbol.

D. Herencia

➢ La herencia es un concepto muy utilizado en PHP, la mayoría de Frameworks son

construidos con objetos heredados con los cuales nosotros interactuamos, a veces sin
darnos cuenta que el objeto que estamos creando es la herencia de un conjunto de otros
objetos.

➢ En la herencia la clase Hija es la que hereda de la clase Padre, de esta forma tenemos una
clase hija que extiende las propiedades de la clase padre.
 Laboratorio 04 - OOP con PHP
Página 8

<?php

// Clase padre
class Animal {
// Propiedades
protected $nombre;
protected $color;

// Constructor
public function __construct($nombre, $color) {
$this->nombre = $nombre;
$this->color = $color;
}

// Método
public function comer($comida) {
return "$this->nombre está comiendo $comida.";
}
}

// Clase hija que hereda de Animal

class Perro extends Animal {
private $raza;

// Constructor
public function __construct($nombre, $color, $raza) {
parent::__construct($nombre, $color);
$this->raza = $raza;
}

public function comer($comida) {

return parent::comer($comida) . " ¡Guau!";
}

public function ladrar() {

return "$this->nombre está ladrando!";
}
}

➢ Podríamos hacer uso de las clases definidas de la siguiente forma:

// Crea objetos
$animal = new Animal("Animal", "Marrón");
$perro = new Perro("Buddy", "Negro", "Labrador");

// Accede a los métodos

echo $animal->comer("hierba") . "<br>"; // Salida: Animal está comiendo hierba.
echo $perro->comer("huesos") . "<br>"; // Salida: Buddy está comiendo huesos.
¡Guau!
echo $perro->ladrar() . "<br>"; // Salida: Buddy está ladrando!

➢ ¿Qué propiedades y/o métodos se están extendiendo de la clase Padre en el ejemplo

proporcionado?
 Laboratorio 04 - OOP con PHP
Página 9

Propiedades y métodos extendidos en el ejemplo

En el ejemplo proporcionado, la clase Perro hereda de la clase Animal. Las propiedades
y métodos que se están extendiendo de la clase Padre a la clase Hija son:
Propiedades:
• nombre: Esta propiedad almacena el nombre del animal.
• color: Esta propiedad almacena el color del animal.
Métodos:
• comer($comida): Este método imprime un mensaje que indica que el animal está
comiendo la comida especificada.

➢ Proponga un ejemplo simple de herencia empleando PHP:

➢ <?php
➢ class Persona {
➢ protected $nombre;
➢ protected $edad
➢ public function __construct($nombre, $edad) {
➢ $this->nombre = $nombre;
➢ $this->edad = $edad;
➢ }
➢ public function saludar() {
➢ return "Hola, mi nombre es {$this->nombre} y tengo {$this->edad} años.";
➢ }
➢ }
➢ class Estudiante extends Persona
➢ protected $carrera;
➢ public function __construct($nombre, $edad, $carrera) {
➢ parent::__construct($nombre, $edad);
➢ $this->carrera = $carrera;
➢ }
➢ public function estudiar() {
➢ return "{$this->nombre} está estudiando {$this->carrera}.";
➢ }
➢ }
 Laboratorio 04 - OOP con PHP
Página 10

VII. OBSERVACIONES
● 1. Encapsulamiento:

Permite ocultar la complejidad interna de una clase.

Facilita el mantenimiento y la reutilización del código.
Puede dificultar la comprensión del código para principiantes.

● 2. Herencia:

Permite reutilizar código y crear relaciones entre clases.

Facilita la creación de jerarquías de clases.
Puede aumentar la complejidad del código si no se utiliza correctamente.

● 3. Polimorfismo:

Permite que diferentes objetos respondan al mismo mensaje de diferentes maneras.

Aumenta la flexibilidad y la reutilización del código.
Puede ser difícil de entender para los principiantes.

● 4. Interfaces:

Permiten definir contratos entre clases.

Facilitan el desacoplamiento de las clases.
Pueden ser difíciles de entender para los principiantes.

● 5. Patrones de diseño:

Soluciones reutilizables para problemas comunes de diseño.

Ayudan a mejorar la calidad del código.
Pueden ser difíciles de aprender y aplicar correctamente.

CONCLUSIONES
● 1. Paradigma poderoso:

La POO es un paradigma de programación poderoso que puede ayudar a crear

aplicaciones más grandes, complejas y mantenibles.

● 2. Mayor flexibilidad:

La POO permite una mayor flexibilidad y reutilización del código.

● 3. Mejora la calidad del código:

 Laboratorio 04 - OOP con PHP
Página 11

La POO puede ayudar a mejorar la calidad del código al hacerlo más modular, organizado
y extensible.

● 4. Curva de aprendizaje:

La POO tiene una curva de aprendizaje más pronunciada que la programación

procedimental.

● 5. Adecuada para proyectos grandes:

La POO es especialmente adecuada para proyectos grandes y complejos.