Herencia de objetos en PHP

¡Hola, genio del código! Bienvenido a una nueva lección de nuestro curso básico de PHP 8. Hoy nos metemos con la herencia de objetos, un truco genial de la programación orientada a objetos (POO) que te ahorra trabajo y hace tu código más poderoso. Si ya manejas clases y objetos, esto es el siguiente paso para brillar. Todo va a ser claro, práctico y con ejemplos que te van a flipar. ¡Empecemos!

¿Qué es la herencia de objetos?

La herencia es como en la vida real: los hijos heredan rasgos de sus padres. En POO, una clase «hija» puede tomar atributos y métodos de una clase «padre», añadiendo o modificando lo que necesite. Esto te deja reutilizar código sin repetirte y extender funcionalidades como un ninja.

Clase padre (base): La original, con lo básico.
Clase hija (derivada): Hereda todo y puede sumar extras o cambiar cosas.

La receta en PHP es esta:

class ClasePadre {
    // Atributos y métodos básicos
}

class ClaseHija extends ClasePadre {
    // Más atributos y métodos, o cambios
}

extends: La palabra mágica que conecta padre e hija.

Probando herencia en acción

¡Manos a la obra! Crea un archivo herencia.php en curso_php8 (dentro de C:\xampp\htdocs) y prueba esto:

Ejemplo 1: Persona y Alumno

<?php
    class Persona {
        public $nombre;
        public $apellido;
        public $fechaNacimiento;

        public function __construct($nombre, $apellido, $fechaNacimiento) {
            $this->nombre = $nombre;
            $this->apellido = $apellido;
            $this->fechaNacimiento = $fechaNacimiento;
        }

        public function getNombreApellido() {
            return "$this->nombre $this->apellido";
        }

        public function calcularEdad() {
            $hoy = new DateTime();
            $nacimiento = new DateTime($this->fechaNacimiento);
            $edad = $hoy->diff($nacimiento);
            return $edad->y . " años";
        }
    }

    class Alumno extends Persona {
        public $carrera;
        public $matricula;

        public function __construct($nombre, $apellido, $fechaNacimiento, $carrera, $matricula) {
            parent::__construct($nombre, $apellido, $fechaNacimiento); // Llama al constructor del padre
            $this->carrera = $carrera;
            $this->matricula = $matricula;
        }

        public function notaCarrera($nota) {
            return "$nota en la carrera de $this->carrera";
        }
    }

    $alumno1 = new Alumno("Daniel", "Mérida", "1995-05-20", "Programación en PHP", "12345");
    echo $alumno1->getNombreApellido() . " tiene " . $alumno1->calcularEdad() . "<br>";
    echo $alumno1->notaCarrera(95) . "<br>";
?>

Abre http://localhost/curso_php8/herencia.php. Verás algo como:

¿Qué pasó?

Persona tiene lo básico: nombre, apellido, edad.
Alumno hereda todo con extends y añade carrera y matrícula.
Usamos parent::__construct() para inicializar lo del padre.

Ejemplo 2: Animal y Perro

<?php
    class Animal {
        public $nombre;

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

        public function emitirSonido() {
            echo "Ruido genérico<br>";
        }
    }

    class Perro extends Animal {
        public function emitirSonido() {
            echo "¡Guau guau!<br>"; // Sobrescribe el método del padre
        }
    }

    $miPerro = new Perro("Max");
    echo "$miPerro->nombre dice: ";
    $miPerro->emitirSonido();
?>

¿Qué pasó?

Animal da un sonido genérico.
Perro hereda y cambia emitirSonido() a algo más perruno.

Ejemplos prácticos

Ejemplo: Vehículo y Moto

<?php
    class Vehiculo {
        public $marca;

        public function __construct($marca) {
            $this->marca = $marca;
        }

        public function mover() {
            echo "El vehículo $this->marca se está moviendo.<br>";
        }
    }

    class Moto extends Vehiculo {
        public function hacerTruco() {
            echo "La moto $this->marca hace un caballito.<br>";
        }
    }

    $miMoto = new Moto("Yamaha");
    $miMoto->mover();
    $miMoto->hacerTruco();
?>

Ejercicios para practicar

¡Tu turno de rockearlo! Ve a curso_php8 y prueba estos retos:

Lenguaje y Framework
Crea lenguaje_framework.php:

<?php
       class Lenguaje {
           public $nombre;

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

           public function describir() {
               echo "Soy el lenguaje $this->nombre.<br>";
           }
       }

       class Framework extends Lenguaje {
           public $version;

           public function __construct($nombre, $version) {
               parent::__construct($nombre);
               $this->version = $version;
           }

           public function describir() {
               echo "Soy $this->nombre, un framework versión $this->version.<br>";
           }
       }

       $php = new Lenguaje("PHP");
       $laravel = new Framework("Laravel", "10");
       $php->describir();
       $laravel->describir();
   ?>

Figura y Cuadrado
Crea figura_cuadrado.php:

<?php
       class Figura {
           public $lado;

           public function __construct($lado) {
               $this->lado = $lado;
           }
       }

       class Cuadrado extends Figura {
           public function area() {
               return $this->lado * $this->lado;
           }

           public function perimetro() {
               return 4 * $this->lado;
           }
       }

       $cuadrado = new Cuadrado(5);
       echo "Área: " . $cuadrado->area() . "<br>";
       echo "Perímetro: " . $cuadrado->perimetro() . "<br>";
   ?>

Ejecuta en localhost/curso_php8/ y juega con los valores.

Consejos para no enredarte

parent: Úsalo para llamar al constructor o métodos del padre.
Sobrescribir: Cambia un método en la hija si necesitas algo diferente.
Prueba todo: Crea objetos de ambas clases (padre e hija) para ver cómo heredan.

¡A por más POO!

¡Gran trabajo, máquina! Ahora la herencia es tu aliada para reutilizar y extender código como pro. En la próxima lección, veremos clases abstractas (no anónimas, como dice el original; parece un error) para llevar la POO al siguiente nivel. Si algo no te queda claro, déjame un comentario .

Lo que aprendiste hoy, estrella:

Qué es herencia: Clases hijas que toman lo mejor de sus padres.
extends: La palabra que hace la magia de heredar.
Ejemplos vivos: Hiciste alumnos y perros con herencia como crack.
Practicaste: Creaste frameworks y cuadrados como ninja.
Tip del pro: Usa parent para conectar con el padre sin repetirte.

Clases y objetos en PHP

Clases anónimas en PHP