Dziedziczenie w PHP: extends, parent:: i nadpisywanie

W PHP klasa dziedziczy po innej przez extends: class Dog extends Animal daje Dog każdą publiczną i chronioną właściwość oraz metodę Animal. Potomek może dodawać nowe metody, nadpisywać odziedziczone, deklarując metodę o tej samej nazwie, i wywoływać oryginał przez 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 nie ma konstruktora, więc używa konstruktora Animal, dlatego new Dog('Rex') działa. Klasa potomna może rozszerzać tylko jednego rodzica; PHP nie ma wielodziedziczenia klas.

Wywołanie metody rodzica przez parent::

Nadpisanie całkowicie zastępuje metodę rodzica. Aby ją rozszerzyć zamiast zastępować, wywołaj parent::method() z potomka i zbuduj coś na jej wyniku:

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

To samo działa dla konstruktorów przez parent::__construct(...), co opisuje strona o konstruktorze, łącznie z tym, co się dzieje, gdy o tym zapomnisz.

protected vs private w klasach potomnych

Element protected jest ukryty przed kodem zewnętrznym, ale widoczny dla każdej klasy w rodzinie. Element private jest widoczny tylko w klasie, która go deklaruje, więc klasa potomna w ogóle go nie widzi:

<?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) daje w potomku fałsz, bo potomek nie ma dostępu do prywatnego $pin rodzica, a własna metoda rodzica hasPin() nadal go czyta. Używaj protected dla tego, na czym podklasy mają budować, a private dla szczegółów, które chcesz móc swobodnie zmieniać.

Polimorfizm i instanceof

Kod napisany dla typu rodzica działa z każdym potomkiem. Każdy obiekt wykonuje własną wersję nadpisanej metody, więc jedna pętla obsługuje je wszystkie. instanceof sprawdza, czy obiekt jest danej klasy albo któregoś z jej potomków:

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

Gdy rodzic nigdy nie powinien być używany samodzielnie (zwykły Shape o polu 0 ma mało sensu), uczyń go klasą abstrakcyjną i zadeklaruj area() jako abstrakcyjną.

Zasady nadpisywania: sygnatury muszą pozostać zgodne

Nadpisująca metoda musi przyjmować co najmniej to, co przyjmował rodzic, i zwracać coś, czego mogą użyć wywołujący rodzica. Możesz dodać parametr opcjonalny, poszerzyć typ parametru albo zawęzić typ zwracany; nie możesz dodać wymaganego parametru ani uczynić metody publicznej prywatną.

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

Zmień string $sep = ',' na wymagane string $sep, a PHP odmówi skompilowania klasy z błędem krytycznym („Declaration of CsvExporter::export(array $rows, string$sep): string must be compatible with Exporter::export(array $rows): string”).

Klasy i metody final

final zatrzymuje dziedziczenie w tym miejscu. Metody final nie można nadpisać, a final class nie można rozszerzyć. Oba przypadki są sprawdzane przy kompilacji pliku, więc skrypt w ogóle się nie uruchamia:

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

Dla klasy final komunikat to Class B cannot extend final class A. Oznacz metodę jako final, gdy rodzic polega na tym, że działa ona dokładnie w jeden sposób, na przykład metoda sprawdzająca uprawnienia przed zrobieniem czegokolwiek innego.

Pułapka z metodami prywatnymi

Metoda prywatna nie jest dziedziczona, więc metoda potomka o tej samej nazwie jej nie nadpisuje. Kod w rodzicu nadal wywołuje własną prywatną wersję, co zaskakuje osoby, które spodziewają się wykonania metody potomka:

<?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() nadal wypisuje Hello: $this->word() w rodzicu wskazuje na prywatną metodę rodzica. Zmień private na protected w Greeter i uruchom ponownie; teraz metoda potomka jest prawdziwym nadpisaniem, a greet() mówi Bonjour.