PHP: Programación Orientada a Objetos

La Programación Orientada a Objetos (POO) en PHP permite diseñar código con una estructura modular, basada en clases y objetos que agrupan lógica y datos de forma coherente. Este enfoque facilita la escalabilidad de proyectos y potencia la reutilización de funcionalidades.

Clases y objetos

En PHP, una clase describe las características y comportamientos de un tipo de objeto. Cada vez que se crea una instancia de esa clase, se obtiene un objeto que hereda todas las propiedades y métodos definidos.

<?php
class Coche {
    public $marca;
    public $modelo;

    public function arrancar() {
        echo "El coche está en marcha.";
    }
}

$miCoche = new Coche();
$miCoche->marca = "Toyota";
$miCoche->modelo = "Corolla";
$miCoche->arrancar();
?>

En este ejemplo, la clase Coche tiene dos atributos (marca y modelo) y un método (arrancar). Con la palabra reservada new creas un objeto a partir de esa clase.

Encapsulación

La encapsulación consiste en proteger los atributos y métodos internos de una clase, de forma que solo puedan modificarse a través de métodos específicos (getters y setters). Esto se controla mediante modificadores de acceso: public, protected y private.

<?php
class Usuario {
    private $nombre;

    public function setNombre($nombre) {
        $this->nombre = $nombre;
    }

    public function getNombre() {
        return $this->nombre;
    }
}

$usuario = new Usuario();
$usuario->setNombre("Lucía");
echo $usuario->getNombre(); // "Lucía"
?>

Al utilizar private, se restringe el acceso directo a la propiedad $nombre, garantizando la integridad de los datos.

Herencia

La herencia permite que una clase hija extienda las propiedades y métodos de otra clase (padre). De este modo, se promueve la reutilización de código y se evita duplicar lógica:

<?php
class Animal {
    public function hacerSonido() {
        echo "Sonido genérico de animal.";
    }
}

class Perro extends Animal {
    public function hacerSonido() {
        echo "¡Guau, guau!";
    }
}

$miPerro = new Perro();
$miPerro->hacerSonido(); // "¡Guau, guau!"
?>

La clase Perro hereda de Animal pero redefine el método hacerSonido para adaptarlo a su caso particular, ejemplificando el uso de polimorfismo.

Polimorfismo

El polimorfismo se manifiesta cuando distintas clases comparten métodos con el mismo nombre, pero cada una implementa su propia lógica. De esta manera, los objetos pueden responder de formas diferentes a la misma llamada de método.

<?php
class Figura {
    public function dibujar() {
        echo "Dibujando una figura genérica.";
    }
}

class Circulo extends Figura {
    public function dibujar() {
        echo "Dibujando un círculo.";
    }
}

class Rectangulo extends Figura {
    public function dibujar() {
        echo "Dibujando un rectángulo.";
    }
}

$formas = [new Circulo(), new Rectangulo()];

foreach ($formas as $forma) {
    $forma->dibujar();
}
?>

Al iterar sobre formas, cada objeto implementa su propia versión del método dibujar, demostrando la flexibilidad de la POO.

Constructores y destructores

En PHP, el método __construct se ejecuta automáticamente al crear un objeto, y se utiliza para inicializar propiedades u otros requisitos. Opcionalmente, se puede usar __destruct para liberar recursos al destruir el objeto.

<?php
class ConexionBD {
    private $enlace;

    public function __construct($servidor, $usuario, $password) {
        $this->enlace = mysqli_connect($servidor, $usuario, $password);
        echo "Conexión establecida.";
    }

    public function __destruct() {
        mysqli_close($this->enlace);
        echo "Conexión cerrada.";
    }
}
?>

Con los constructores y destructores se automatizan procedimientos que ocurren al inicio y al final del ciclo de vida del objeto.

Interfaces y clases abstractas

Para definir contratos que deban cumplir varias clases, se utilizan interfaces. Estas describen métodos sin implementación:

<?php
interface Volable {
    public function volar();
}

class Pajaro implements Volable {
    public function volar() {
        echo "El pájaro está volando.";
    }
}
?>

Las clases abstractas funcionan de manera similar, pero permiten definir tanto métodos sin cuerpo como métodos con lógica. Las clases que la extienden deben completar los métodos abstractos.

Recomendaciones y buenas prácticas

• Usa nombres descriptivos para clases, métodos y propiedades, evitando abreviaturas confusas.
• Mantén una estructura clara en cada clase, separando el constructor, los métodos públicos y los métodos privados.
• Aplica el principio de responsabilidad única, procurando que cada clase se encargue de una tarea concreta.
• Recurre a la herencia con moderación, prefiriendo la composición en situaciones donde sea posible.