Concepto de Programación Orientada a Objetos (POO) en PHP con un ejemplo

¿Qué son los POO?

La programación orientada a objetos es un enfoque de desarrollo de software que modela una aplicación en torno a objetos del mundo real, como empleados, automóviles y cuentas bancarias. Una clase define las propiedades y los métodos de un objeto del mundo real. Un objeto es una instancia de una clase.

Los tres componentes básicos de la orientación a objetos son:

• Análisis orientado a objetos – funcionalidad del sistema
• Diseño orientado a objetos: arquitectura del sistema
• Programación orientada a objetos – implementación de la aplicación

Principios de programación orientada a objetos

Los tres principios principales de la programación orientada a objetos son:

• La encapsulación – Esto se refiere a ocultar los detalles de implementación y exponer únicamente los métodos. Los principales propósitos de la encapsulación son:
  • Reduce la complejidad del desarrollo de software: al ocultar los detalles de implementación y exponer solo las operaciones, usar una clase se vuelve fácil.
  • Protege el estado interno de un objeto: el acceso a las variables de la clase se realiza mediante métodos como get y set. Esto hace que la clase sea flexible y fácil de mantener.
  • Permite modificar la implementación interna de la clase sin preocuparse por romper el código que la utiliza.
• Herencia – Esto se refiere a la relación entre clases. La relación adopta la forma de padre e hijo. El hijo utiliza los métodos definidos en la clase padre. El propósito principal de la herencia es:
  • Reutilización: varios elementos secundarios pueden heredar de un mismo elemento principal. Esto resulta muy útil cuando necesitamos proporcionar funcionalidades comunes, como agregar, actualizar y eliminar datos de la base de datos.
• Polimorfismo – Esto se refiere a tener una única interfaz con muchas implementaciones diferentes. El propósito principal del polimorfismo es:
  • Para simplificar el mantenimiento de las aplicaciones y hacerlas más extensibles.

UPS Concepts en PHP

PHP es un lenguaje de scripting orientado a objetos; admite todos los principios mencionados anteriormente. Estos principios se logran mediante:

• La encapsulación – mediante el uso de los métodos “get” y “set”, y modificadores de acceso.
• Herencia – mediante el uso de la palabra clave extends
• Polimorfismo – mediante el uso de la palabra clave implements

Ahora que tenemos el conocimiento básico de la programación orientada a objetos y cómo se soporta en PHPVeamos algunos ejemplos que implementan los principios anteriores.

¿Qué es UML?

El Lenguaje Unificado de Modelado (UML) es una técnica utilizada para diseñar y documentar sistemas orientados a objetos.

UML genera varios documentos, pero nos centraremos en el diagrama de clases, que es muy importante para la programación orientada a objetos en PHP.

Ejemplo de diagrama de clases

Clave del diagrama de clases

• El caja superior contiene el nombre de la clase
• El caja del medio contiene las variables de clase
• El caja inferior contiene los métodos de clase
• El menos (-) El signo significa ámbito privado
• El más (+) signo significa alcance público
• El hash (#) signo significa alcance protegido

Cómo crear una clase en PHP

La palabra clave class se utiliza para definir una clase en PHP. A continuación se detallan las reglas para crear una clase en PHP.

• El nombre de la clase debe comenzar con una letra.
• El nombre de la clase no puede ser una palabra reservada de PHP
• El nombre de la clase no puede contener espacios.

Digamos que queremos crear una clase para representar a los animales. Comenzaremos por identificar las características que son comunes a todos los animales.

• Todos los animales pertenecen a una familia, como herbívoros, carnívoros, etc.
• Todos los animales comen comida.

El siguiente diagrama muestra el diagrama de clases para el animal.

Ahora vamos a codificar nuestra clase Animal.

<?php
class Animal
{
    private $family;
    private $food;
    public function __construct($family, $food)
    {
        $this->family = $family;
        $this->food = $food;
    }
    public function get_family()
    {
        return $this->family;
    }
    public function set_family($family)
    {
        $this->family = $family;
    }
    public function get_food()
    {
        return $this->food;
    }
    public function set_food($food)
    {
        $this->food = $food;
    }
}
?>

AQUÍ,

• “private $family, $food” significa que no se puede acceder a las variables directamente fuera de la clase (encapsulación).
• “public function __construct($family…)” es el método constructor de PHP. Esta función se llama cada vez que se crea una instancia de la clase. En este caso, estamos definiendo la familia y la comida.
• “public function get…()” es el método utilizado para acceder al valor de la familia o del alimento (encapsulación).
• “public function set…()” es el método utilizado para establecer el valor de la familia o del alimento (encapsulación).

Cómo implementar la herencia en PHP

Trabajaremos con una vaca y un león. Tanto la vaca como el león heredan de la clase Animal.

El siguiente diagrama de clases muestra las relaciones.

Nótese que la vaca hereda de la clase Animal y define sus propias variables y métodos.

Vamos a codificar ahora la clase Vaca.

<?php
class Cow extends Animal
{
    private $owner;
    public function __construct($family, $food)
    {
        parent::__construct($family, $food);
    }
    public function set_owner($owner)
    {
        $this->owner = $owner;
    }
    public function get_owner()
    {
        return $this->owner;
    }
}
?>

Ahora vamos a codificar la clase León.

<?php
class Lion extends Animal
{
    public function __construct($family, $food)
    {
        parent::__construct($family, $food);
    }
}
?>

AQUÍ,

• La instrucción “class … extends Animal” hace que las clases Cow y Lion utilicen métodos de la clase Animal (herencia).

Cómo crear un objeto de la clase

Por razones de simplicidad, las clases Animal, Vaca y León deberían estar todas en el mismo directorio.

Ahora vamos a crear la aplicación que utiliza nuestras clases.

Ejemplo de clase PHP

<?php
require 'Animal.php';
require 'Cow.php';
require 'Lion.php';
$cow = new Cow('Herbivore', 'Grass');
$lion = new Lion('Carnivore', 'Meat');
echo '<b>Cow Object</b> <br>';
echo 'The Cow belongs to the ' . $cow->get_family() . ' family and eats ' . $cow->get_food() . '<br><br>';
echo '<b>Lion Object</b> <br>';
echo 'The Lion belongs to the ' . $lion->get_family() . ' family and eats ' . $lion->get_food();
?>

Probar nuestra aplicación

Ahora vamos a ver nuestra aplicación en un navegador web.

Ambos objetos reutilizan los métodos get_family y get_food heredados de la clase Animal, lo que demuestra la herencia en acción.

Cómo implementar el polimorfismo en PHP

Digamos que queremos desarrollar una aplicación que se conecte a diferentes motores de bases de datos como MySQL y SQL Servidor, pero utiliza la misma interfaz uniforme. Podemos crear una interfaz que defina los métodos estándar y un abs.tracclase t que implementa los métodos comunes.

• Fácil de usar – es similar a una clase. Solo define los métodos y parámetros.
• Abstracclase t – es una clase que no se puede utilizar para crear un objeto directamente. Su propósito es proporcionar implementaciones parciales o totales de métodos comunes.

El diagrama de clases que se muestra a continuación ilustra la relación entre nuestros abstracClases de clase, interfaz e implementación.

Ahora vamos a crear nuestros abdominales.tracclase t.

<?php
abstract class DBCommonMethods
{
    private $host;
    private $db;
    private $uid;
    private $password;
    public function __construct($host, $db, $uid, $password)
    {
        $this->host = $host;
        $this->db = $db;
        $this->uid = $uid;
        $this->password = $password;
    }
}
?>

AQUÍ,

• “abdominalestrac"clase t" significa que la clase no se puede usar directamente para crear un objeto.
• “$host, $db…” son variables de clase comunes a todas las implementaciones.
• “function __construct(…)” es el método constructor de la clase que establece los valores de las variables comunes en la inicialización.

Ahora vamos a crear la interfaz que contiene los métodos estándar, que se implementarán de forma diferente según el motor de base de datos.

<?php
interface DBInterface
{
    public function db_connect();
    public function insert($data);
    public function read($where);
    public function update($where);
    public function delete($where);
}
?>

AQUÍ,

• "interfaz" es la palabra clave para crear interfaces
• “función pública…(…)” son los métodos estándar que deben implementarse

Ahora vamos a crear las clases concretas que extenderán la clase DBCommonMethods e implementarán la interfaz DBInterface. Primero, MySQLDriver.php:

<?php
class MySQLDriver extends DBCommonMethods implements DBInterface
{
    public function __construct($host, $db, $uid, $password)
    {
        parent::__construct($host, $db, $uid, $password);
    }
    public function db_connect() { /* connect code goes here */ }
    public function delete($where) { /* delete code goes here */ }
    public function insert($data)  { /* insert code goes here */ }
    public function read($where)   { /* read code goes here */ }
    public function update($where) { /* update code goes here */ }
}
?>

Luego, MSSQLServerDriver.php:

<?php
class MSSQLServerDriver extends DBCommonMethods implements DBInterface
{
    public function __construct($host, $db, $uid, $password)
    {
        parent::__construct($host, $db, $uid, $password);
    }
    public function db_connect() { /* connect code goes here */ }
    public function delete($where) { /* delete code goes here */ }
    public function insert($data)  { /* insert code goes here */ }
    public function read($where)   { /* read code goes here */ }
    public function update($where) { /* update code goes here */ }
}
?>

AQUÍ,

• “class … extends DBCommonMethods” utiliza los métodos de DBCommonMethods.
• “… implementa DBInterface” garantiza que la clase proporcione los métodos estándar independientemente del controlador de base de datos utilizado.

El código que utiliza las clases anteriores se vería así:

<?php $db = new MySQLDriver($host, $db, $uid, $password); ?>

o:

<?php $db = new MSSQLServerDriver($host, $db, $uid, $password); ?>

El resto del código sería el mismo para ambos controladores, como por ejemplo:

<?php
$db->db_connect();
$db->insert($data);
?>

Esto es polimorfismo en acción: las mismas llamadas a métodos funcionan en cualquier controlador que implemente la interfaz, por lo que el código circundante nunca cambia cuando se cambia de motor de base de datos.

Preguntas Frecuentes