Clases y Objetos en PHP 🧩

Objetivo: Esta guía está pensada para alguien con conocimientos básicos de programación en PHP (variables, funciones y estructuras de control). Aquí aprenderás desde los conceptos más importantes de la Programación Orientada a Objetos (POO) hasta ejemplos prácticos explicados paso a paso.

---

🔎 ¿Qué es la POO? (explicación clara)

La Programación Orientada a Objetos (POO) es una forma de organizar el código usando clases y objetos:

• Clase: es una plantilla (como el plano de una casa). Define propiedades (datos) y métodos (comportamientos).
• Objeto: es una instancia de la clase, como una casa construida a partir del plano.

¿Por qué usarla? Porque ayuda a:

• Organizar el código.
• Reusar código (no repetir).
• Modelar entidades del mundo real (usuario, producto, carrito).
• Facilitar mantenimiento y pruebas.

---

🏗️ Sintaxis básica: definir una clase paso a paso

Ejemplo básico (desglosado)

<?php
class Persona {
    public string $nombre;   // propiedad pública
    private int $edad;       // propiedad privada

    // Constructor: se ejecuta al crear la instancia
    public function __construct(string $nombre, int $edad) {
        $this->nombre = $nombre; // asigna la propiedad 'nombre'
        $this->edad = $edad;     // asigna la propiedad 'edad'
    }

    // Método: comportamiento de la clase
    public function saludar(): string {
        return "Hola, soy {$this->nombre} y tengo {$this->edad} años.";
    }
}

// Crear (instanciar) un objeto
$p = new Persona("Andrés", 30);
echo $p->saludar(); // Muestra: Hola, soy Andrés y tengo 30 años.

Explicación línea por línea

• class Persona { ... } define la plantilla.
• public string $nombre; es una propiedad accesible desde fuera.
• private int $edad; es una propiedad que sólo la clase puede usar directamente.
• __construct(...) es el constructor: recibe parámetros y prepara el objeto.
• $this->nombre refiere a la propiedad nombre del objeto actual.
• new Persona(...) crea una instancia (un objeto).

---

⚙️ Constructores y property promotion (PHP 8)

Antes de PHP 8 había que declarar propiedades y luego asignarlas en el constructor. PHP 8 introdujo constructor property promotion para ahorrar código.

Forma clásica (PHP 7.x y anterior):

class UsuarioOld {
    public string $nombre;
    private string $email;

    public function __construct(string $nombre, string $email) {
        $this->nombre = $nombre;
        $this->email = $email;
    }
}

Con property promotion (PHP 8+):

class Usuario {
    public function __construct(
        public string $nombre,
        private string $email
    ) {}
}
$u = new Usuario("Ana", "ana@example.com");
echo $u->nombre; // Ana

Consejo: usa promotion para DTOs y clases simples; para lógica compleja dentro del constructor usa la forma clásica.

---

🔒 Visibilidad: public, protected, private (con ejemplos prácticos)

• public: accesible desde cualquier sitio.
• protected: accesible en la clase y sus subclases.
• private: accesible sólo dentro de la misma clase.

Ejemplo con getters/setters (buena práctica):

class Cuenta {
    private float $saldo = 0.0;

    public function depositar(float $monto): void {
        if ($monto <= 0) throw new InvalidArgumentException("Monto inválido");
        $this->saldo += $monto;
    }

    // getter público para consultar saldo
    public function obtenerSaldo(): float {
        return $this->saldo;
    }
}

$c = new Cuenta();
$c->depositar(100.50);
echo $c->obtenerSaldo(); // 100.5

Por qué usar private ? Para proteger el estado del objeto y validar cambios desde métodos controlados.

---

🧲 Static: propiedades y métodos compartidos

Las propiedades/métodos static pertenecen a la clase (no a la instancia).

class Contador {
    public static int $cuenta = 0;

    public static function incrementar(): void {
        self::$cuenta++;
    }
}

Contador::incrementar();
echo Contador::$cuenta; // 1

Cuándo usar: datos globales a todas las instancias (por ejemplo, contador de objetos, configuración compartida).

---

🧬 Herencia y override (sobrescribir métodos)

Permite crear clases hijas a partir de una clase padre.

class Animal {
    public function hablar(): string {
        return "...";
    }
}

class Perro extends Animal {
    public function hablar(): string {
        return "Guau";
    }
}

$perro = new Perro();
echo $perro->hablar(); // Guau

Nota práctica: si la clase hija necesita inicializar propiedades del padre, usa parent::__construct(...).

---

🧠 Abstract classes e Interfaces (contratos)

Abstract class: sirve como base y puede definir tanto métodos concretos como abstractos (sin implementación).

abstract class Figura {
    abstract public function area(): float;
    public function descripcion(): string {
        return "Soy una figura";
    }
}

class Rectangulo extends Figura {
    public function __construct(private float $ancho, private float $alto) {}
    public function area(): float {
        return $this->ancho * $this->alto;
    }
}

Interface: define un contrato puro; cualquier clase que implemente la interface debe definir esos métodos.

interface Jsonable {
    public function toJson(): string;
}

class Producto implements Jsonable {
    public function __construct(public string $nombre, public float $precio) {}
    public function toJson(): string {
        return json_encode(get_object_vars($this));
    }
}

Cuándo usar cada uno:

• Usa interface cuando quieras garantizar métodos sin preocuparte por la implementación.
• Usa abstract cuando quieras una base con algo de comportamiento y también que obligue a implementar ciertos métodos.

---

🧩 Traits: reusar comportamiento sin herencia

Los traits permiten compartir métodos entre clases sin forzar una relación padre-hijo.

trait Logger {
    public function log(string $msg): void {
        echo "[LOG] $msg
";
    }
}

class Servicio {
    use Logger;
}

$s = new Servicio();
$s->log("Listo."); // [LOG] Listo.

Precaución: evita abusar de traits; úsalos para pequeñas utilidades reutilizables.

---

✨ Métodos mágicos (mecanismos automáticos útiles)

Los métodos mágicos son funciones especiales que PHP llama en determinados eventos:

• __construct() — al crear la instancia.
• __destruct() — al destruir la instancia.
• __toString() — cuando el objeto se trata como string.
• __get($name) / __set($name, $value) — al acceder a propiedades inaccesibles o inexistentes.
• __call($name, $arguments) — llamadas a métodos no existentes en la instancia.
• __callStatic(...) — llamadas a métodos estáticos inexistentes.
• __clone() — al clonar un objeto.
• __sleep() / __wakeup() — para serialización.

Ejemplo sencillo con __get y __toString:

class Caja {
    private array $data = [];
    public function __get($k) { return $this->data[$k] ?? null; }
    public function __set($k, $v) { $this->data[$k] = $v; }
    public function __toString(): string { return json_encode($this->data); }
}

$c = new Caja();
$c->hola = "mundo";
echo $c->hola; // mundo
echo $c; // {"hola":"mundo"}

---

🪄 Clonación y copiar objetos correctamente

clone $a crea una copia superficial (shallow copy). Si las propiedades incluyen objetos, ambas instancias compartirán referencias a esos objetos a menos que implementes __clone().

Ejemplo de clonación profunda (deep clone):

class Sub {
    public function __construct(public array $items = []) {}
}

class Padre {
    public Sub $sub;
    public function __construct() {
        $this->sub = new Sub();
    }
    public function __clone() {
        // clonar el objeto contenido para no compartir la referencia
        $this->sub = clone $this->sub;
    }
}

$a = new Padre();
$a->sub->items[] = 1;

$b = clone $a;
$b->sub->items[] = 2;

print_r($a->sub->items); // [1]
print_r($b->sub->items); // [1,2]

---

🛠️ Ejemplo práctico extendido: mini-CRUD en memoria (explicado)

<?php
// Entidad User simple
class User {
    public function __construct(
        public int $id,
        public string $name,
        public string $email
    ) {}
}

// Repositorio: responsable de almacenar/recuperar usuarios
class UserRepository {
    /** @var array<int, User> */
    private array $store = [];

    public function save(User $u): void {
        $this->store[$u->id] = $u;
    }

    public function find(int $id): ?User {
        return $this->store[$id] ?? null;
    }

    public function all(): array {
        return array_values($this->store);
    }

    public function delete(int $id): void {
        unset($this->store[$id]);
    }
}

// Uso:
$repo = new UserRepository();
$repo->save(new User(1, 'María', 'maria@example.com'));
$repo->save(new User(2, 'Luis', 'luis@example.com'));

$user = $repo->find(1);
if ($user) {
    echo $user->name; // María
}

print_r($repo->all());

Explicación práctica:

• UserRepository actúa como una capa de persistencia (aunque aquí sea en memoria).
• Mantén la lógica de almacenamiento separada de la entidad User (principio de responsabilidad única).

---

⚠️ Manejo de errores y validaciones (ejemplo)

class Validator {
    public static function emailValido(string $email): bool {
        return filter_var($email, FILTER_VALIDATE_EMAIL) !== false;
    }
}

try {
    $email = "no-valido";
    if (!Validator::emailValido($email)) {
        throw new InvalidArgumentException("Email inválido: $email");
    }
} catch (InvalidArgumentException $e) {
    echo $e->getMessage();
}

Tip: usa excepciones para errores que no deberían ocurrir en el flujo normal y valida siempre datos de entrada.

---

✅ Buenas prácticas resumidas

• Usa type hints (parámetros y retornos).
• Valida datos de entrada (excepciones o resultados controlados).
• Prefiere composición sobre herencia (usa objetos dentro de objetos cuando sea más lógico).
• Mantén clases pequeñas y con una sola responsabilidad (SRP).
• Documenta con docblocks y escribe pruebas unitarias (PHPUnit).
• No hagas propiedades públicas si necesitas controlar acceso; usa getters/setters o readonly en PHP 8.1+.

---

✍️ Ejercicios para practicar (con pistas)

1. Crear una clase Producto con id, nombre, precio. Implementa descuento(float $p) que reduzca el precio en p%.
   • Pista: valida que el porcentaje sea entre 0 y 100.
2. Crear interfaz Persistible con métodos save() y delete(). Haz que UserRepository implemente esta interfaz.
3. Ejercicio avanzado: crear Order que tenga una lista de Product. Implementa método total() que sume precios. Asegura que Order pueda serializarse a JSON.

---

📚 Glosario rápido

• Instancia / objeto: copia concreta de una clase.
• Propiedad: variable dentro de la clase.
• Método: función definida en la clase.
• Constructor: método que inicializa la instancia.
• Visibilidad: control de acceso (public/protected/private).
• Trait: mezcla de métodos reutilizables.
• Interface: contrato de métodos sin implementación.

---

❓ FAQ (rápidas)

¿Cuándo usar una clase vs un array?
Usa una clase cuando quieras representar una entidad con comportamiento y reglas; usa arrays para datos sencillos y temporales.

¿Pueden las clases tener funciones fuera de clases?
Sí, pero mantener la lógica relacionada dentro de clases mejora la organización.

¿Debo usar siempre getters/setters en PHP?
No siempre; para DTOs simples public es aceptable. Para lógica/validación usa getters/setters.

---

🏁 Resumen final

• Aprende los conceptos básicos (clase, objeto, constructor, $this).
• Practica con ejemplos: crear clases, usar herencia, interfaces y traits.
• Usa validaciones y excepciones para código robusto.
• Aplica buenas prácticas: tipado, SRP y pruebas.

---

Video Breve