Herencia en PHP: extends, parent:: y sobrescribir métodos

En PHP una clase hereda de otra con extends: class Dog extends Animal le da a Dog todas las propiedades y métodos públicos y protegidos de Animal. La hija puede añadir métodos nuevos, sobrescribir los heredados declarando un método con el mismo nombre y llamar al original con parent::method().

<?php
class Animal
{
    public function __construct(protected string $name) {}

    public function speak(): string
    {
        return "{$this->name} makes a sound";
    }

    public function name(): string
    {
        return $this->name;
    }
}

class Dog extends Animal
{
    public function speak(): string
    {
        return "{$this->name} barks";
    }

    public function fetch(): string
    {
        return "{$this->name} brings the ball back";
    }
}

$generic = new Animal('Some animal');
$rex = new Dog('Rex');

echo $generic->speak(), "\n";
echo $rex->speak(), "\n";     // overridden
echo $rex->name(), "\n";      // inherited
echo $rex->fetch(), "\n";     // added

Dog no tiene constructor, así que usa el de Animal, y por eso funciona new Dog('Rex'). Una clase hija solo puede extender un padre; PHP no tiene herencia múltiple de clases.

Llamar al método del padre con parent::

Sobrescribir sustituye por completo el método del padre. Para ampliarlo en lugar de sustituirlo, llama a parent::method() desde la hija y construye sobre su resultado:

<?php
class Report
{
    public function header(): string
    {
        return "Sales report";
    }

    public function lines(): array
    {
        return ['Q1: 120', 'Q2: 98'];
    }
}

class DetailedReport extends Report
{
    public function header(): string
    {
        return parent::header() . " (detailed)";
    }

    public function lines(): array
    {
        $lines = parent::lines();
        $lines[] = 'Total: 218';
        return $lines;
    }
}

$r = new DetailedReport();
echo $r->header(), "\n";
echo implode("\n", $r->lines()), "\n";

Lo mismo funciona con los constructores mediante parent::__construct(...), que explica la página del constructor, incluido lo que pasa cuando lo olvidas.

protected vs private en las clases hijas

Un miembro protected está oculto para el código de fuera pero es visible para todas las clases de la familia. Un miembro private solo es visible en la clase que lo declara, así que una clase hija no puede verlo en absoluto:

<?php
class BankAccount
{
    protected float $balance = 100;
    private string $pin = '1234';

    public function hasPin(): bool
    {
        return $this->pin !== '';
    }
}

class SavingsAccount extends BankAccount
{
    public function addInterest(float $rate): void
    {
        $this->balance *= 1 + $rate;   // protected: allowed
    }

    public function balance(): float
    {
        return $this->balance;
    }

    public function pinKnown(): bool
    {
        return isset($this->pin);      // private in the parent: not visible here
    }
}

$s = new SavingsAccount();
$s->addInterest(0.05);
echo $s->balance(), "\n";
var_dump($s->pinKnown(), $s->hasPin());

isset($this->pin) es falso en la hija porque la hija no tiene acceso al $pin privado del padre, mientras que el propio método del padre, hasPin(), sí lo lee. Usa protected para lo que las subclases deben aprovechar, y private para los detalles que quieres poder cambiar libremente.

Polimorfismo e instanceof

El código escrito para el tipo padre funciona con cada hija. Cada objeto ejecuta su propia versión de un método sobrescrito, así que un solo bucle los maneja a todos. instanceof comprueba si un objeto es de una clase o de cualquiera de sus hijas:

<?php
class Shape
{
    public function area(): float
    {
        return 0;
    }
}

class Rectangle extends Shape
{
    public function __construct(private float $w, private float $h) {}

    public function area(): float
    {
        return $this->w * $this->h;
    }
}

class Circle extends Shape
{
    public function __construct(private float $r) {}

    public function area(): float
    {
        return M_PI * $this->r ** 2;
    }
}

function totalArea(Shape ...$shapes): float
{
    return array_sum(array_map(fn (Shape $s) => $s->area(), $shapes));
}

$shapes = [new Rectangle(3, 4), new Circle(1), new Rectangle(2, 2)];
printf("Total area: %.2f\n", totalArea(...$shapes));

foreach ($shapes as $s) {
    echo get_class($s), ': ', $s instanceof Shape ? 'is a Shape' : 'not a Shape';
    echo $s instanceof Circle ? ', is a Circle' : '', "\n";
}
echo get_parent_class(new Circle(2)), "\n";

Cuando el padre nunca deba usarse por sí solo (un Shape genérico con área 0 tiene poco sentido), hazlo clase abstracta y declara area() como abstracto.

Reglas de la sobrescritura: las firmas deben seguir siendo compatibles

Un método que sobrescribe debe aceptar al menos lo que aceptaba el padre y devolver algo que puedan usar quienes llamaban al padre. Puedes añadir un parámetro opcional, ampliar el tipo de un parámetro o restringir el tipo de retorno; no puedes añadir un parámetro obligatorio ni hacer privado un método público.

<?php
class Exporter
{
    public function export(array $rows): string
    {
        return implode(';', array_map(fn ($r) => implode(',', $r), $rows));
    }
}

class CsvExporter extends Exporter
{
    // Adds an optional parameter: compatible
    public function export(array $rows, string $sep = ','): string
    {
        return implode("\n", array_map(fn ($r) => implode($sep, $r), $rows));
    }
}

$rows = [['id', 'name'], [1, 'Ada'], [2, 'Linus']];
echo (new Exporter())->export($rows), "\n\n";
echo (new CsvExporter())->export($rows), "\n\n";
echo (new CsvExporter())->export($rows, "\t"), "\n";

Cambia string $sep = ',' por un string $sep obligatorio y PHP se niega a compilar la clase con un error fatal ("Declaration of CsvExporter::export(array $rows, string$sep): string must be compatible with Exporter::export(array $rows): string").

Clases y métodos final

final detiene la herencia en ese punto. Un método final no se puede sobrescribir, y una final class no se puede extender. Las dos cosas se comprueban al compilar el archivo, así que el script ni siquiera empieza:

<?php
class Payment
{
    final public function charge(int $cents): string
    {
        return "charged $cents";
    }
}

class FreePayment extends Payment
{
    public function charge(int $cents): string
    {
        return 'free';
    }
}

PHP Fatal error:  Cannot override final method Payment::charge() in /home/index.php on line 12

Para una clase final, el mensaje es Class B cannot extend final class A. Marca un método como final cuando el padre dependa de que se comporte exactamente de una forma, por ejemplo un método que comprueba los permisos antes de hacer nada más.

La trampa de los métodos privados

Un método privado no se hereda, así que un método hijo con el mismo nombre no lo sobrescribe. El código del padre sigue llamando a su propia versión privada, lo que sorprende a quien espera que se ejecute el método de la hija:

<?php
class Greeter
{
    public function greet(): string
    {
        return $this->word() . ', world';
    }

    private function word(): string
    {
        return 'Hello';
    }
}

class FrenchGreeter extends Greeter
{
    public function word(): string
    {
        return 'Bonjour';
    }
}

echo (new FrenchGreeter())->greet(), "\n";
echo (new FrenchGreeter())->word(), "\n";

greet() sigue imprimiendo Hello: el $this->word() del padre se resuelve con el método privado del padre. Cambia private por protected en Greeter y vuelve a ejecutarlo; ahora el método de la hija es una sobrescritura real y greet() dice Bonjour.