Ereditarietà in PHP: extends, parent:: e override

In PHP una classe eredita da un'altra con extends: class Dog extends Animal dà a Dog ogni proprietà e metodo public e protected di Animal. La figlia può aggiungere nuovi metodi, sovrascrivere quelli ereditati dichiarando un metodo con lo stesso nome e chiamare l'originale 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 non ha un costruttore, quindi usa quello di Animal, ed è per questo che new Dog('Rex') funziona. Una classe figlia può estendere un solo padre; PHP non ha l'ereditarietà multipla delle classi.

Chiamare il metodo del padre con parent::

L'override sostituisce completamente il metodo del padre. Per estenderlo invece di sostituirlo, chiama parent::method() dalla figlia e costruisci sul suo risultato:

<?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 stesso vale per i costruttori con parent::__construct(...), trattato nella pagina sul costruttore, compreso cosa succede quando lo dimentichi.

protected vs private nelle classi figlie

Un membro protected è nascosto al codice esterno ma visibile a ogni classe della famiglia. Un membro private è visibile solo nella classe che lo dichiara, quindi una classe figlia non può vederlo affatto:

<?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) è falso nella figlia perché la figlia non ha accesso al $pin privato del padre, mentre il metodo del padre hasPin() lo legge ancora. Usa protected per ciò su cui le sottoclassi devono costruire, e private per i dettagli che vuoi restare libero di cambiare.

Polimorfismo e instanceof

Il codice scritto per il tipo padre funziona con ogni figlia. Ogni oggetto esegue la propria versione di un metodo sovrascritto, quindi un solo ciclo li gestisce tutti. instanceof verifica se un oggetto appartiene a una classe o a una delle sue figlie:

<?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";

Quando il padre non deve mai essere usato da solo (un semplice Shape con area 0 ha poco senso), rendilo una classe astratta e dichiara area() abstract.

Regole dell'override: le firme devono restare compatibili

Un metodo che sovrascrive deve accettare almeno ciò che accettava il padre e restituire qualcosa che i chiamanti del padre possano usare. Puoi aggiungere un parametro facoltativo, ampliare il tipo di un parametro o restringere il tipo restituito; non puoi aggiungere un parametro obbligatorio né rendere privato un metodo pubblico.

<?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 = ',' in un string $sep obbligatorio e PHP si rifiuta di compilare la classe con un errore fatale ("Declaration of CsvExporter::export(array $rows, string$sep): string must be compatible with Exporter::export(array $rows): string").

Classi e metodi final

final ferma l'ereditarietà in quel punto. Un metodo final non può essere sovrascritto, e una final class non può essere estesa. Entrambi vengono verificati quando il file viene compilato, quindi lo script non parte affatto:

<?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

Per una classe final il messaggio è Class B cannot extend final class A. Rendi final un metodo quando il padre conta sul fatto che si comporti esattamente in un modo, per esempio un metodo che verifica i permessi prima di fare qualsiasi altra cosa.

La trappola dei metodi privati

Un metodo privato non viene ereditato, quindi un metodo della figlia con lo stesso nome non lo sovrascrive. Il codice del padre continua a chiamare la propria versione privata, il che sorprende chi si aspetta che venga eseguito il metodo della figlia:

<?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() stampa ancora Hello: il $this->word() del padre si risolve nel metodo privato del padre. Cambia private in protected in Greeter ed eseguilo di nuovo; ora il metodo della figlia è un vero override e greet() dice Bonjour.