PHP Vererbung: extends, parent:: und Überschreiben

In PHP erbt eine Klasse mit extends von einer anderen: class Dog extends Animal gibt Dog jede öffentliche und geschützte Eigenschaft und Methode von Animal. Das Kind kann neue Methoden hinzufügen, geerbte überschreiben, indem es eine Methode mit demselben Namen deklariert, und das Original mit parent::method() aufrufen.

<?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 hat keinen Konstruktor, also verwendet es den von Animal, und deshalb funktioniert new Dog('Rex'). Eine Kindklasse kann nur eine Elternklasse erweitern; PHP hat keine Mehrfachvererbung von Klassen.

Die Methode der Elternklasse mit parent:: aufrufen

Überschreiben ersetzt die Methode der Elternklasse vollständig. Um sie zu erweitern, statt sie zu ersetzen, rufst du im Kind parent::method() auf und baust auf dem Ergebnis auf:

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

Dasselbe funktioniert bei Konstruktoren mit parent::__construct(...), was die Seite zum Konstruktor behandelt, einschließlich dessen, was passiert, wenn du es vergisst.

protected vs private in Kindklassen

Ein protected-Member ist vor äußerem Code verborgen, aber für jede Klasse der Familie sichtbar. Ein private-Member ist nur in der Klasse sichtbar, die es deklariert, also sieht eine Kindklasse es überhaupt nicht:

<?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) ist im Kind falsch, weil das Kind keinen Zugriff auf das private $pin der Elternklasse hat, während die eigene Methode hasPin() der Elternklasse es weiterhin liest. Verwende protected für das, worauf Unterklassen aufbauen sollen, und private für Details, die du frei ändern können willst.

Polymorphie und instanceof

Code, der gegen den Elterntyp geschrieben ist, funktioniert mit jedem Kind. Jedes Objekt führt seine eigene Version einer überschriebenen Methode aus, also behandelt eine Schleife alle. instanceof prüft, ob ein Objekt zu einer Klasse oder einem ihrer Kinder gehört:

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

Wenn die Elternklasse nie allein verwendet werden soll (ein einfaches Shape mit Fläche 0 ergibt wenig Sinn), machst du sie zu einer abstrakten Klasse und deklarierst area() als abstract.

Regeln beim Überschreiben: Signaturen müssen kompatibel bleiben

Eine überschreibende Methode muss mindestens das annehmen, was die Elternklasse angenommen hat, und etwas zurückgeben, das die Aufrufer der Elternklasse verwenden können. Du darfst einen optionalen Parameter hinzufügen, einen Parametertyp erweitern oder einen Rückgabetyp einschränken; du darfst keinen Pflichtparameter hinzufügen und keine öffentliche Methode privat machen.

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

Ändere string $sep = ',' in ein Pflicht-string $sep, und PHP weigert sich, die Klasse zu kompilieren, mit einem fatalen Fehler („Declaration of CsvExporter::export(array $rows, string$sep): string must be compatible with Exporter::export(array $rows): string“).

Finale Klassen und Methoden

final beendet die Vererbung an dieser Stelle. Eine final-Methode kann nicht überschrieben werden, und eine final class lässt sich nicht erweitern. Beides wird beim Kompilieren der Datei geprüft, also startet das Skript gar nicht erst:

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

Bei einer finalen Klasse lautet die Meldung Class B cannot extend final class A. Markiere eine Methode als final, wenn die Elternklasse sich darauf verlässt, dass sie sich genau auf eine Weise verhält, zum Beispiel eine Methode, die Berechtigungen prüft, bevor sie irgendetwas anderes tut.

Die Falle mit privaten Methoden

Eine private Methode wird nicht vererbt, also überschreibt eine Methode des Kindes mit demselben Namen sie nicht. Code in der Elternklasse ruft weiterhin seine eigene private Version auf, was alle überrascht, die erwarten, dass die Methode des Kindes läuft:

<?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() gibt weiterhin Hello aus: $this->word() in der Elternklasse löst sich zur privaten Methode der Elternklasse auf. Ändere in Greeter private in protected und führe den Code erneut aus; jetzt ist die Methode des Kindes ein echtes Überschreiben, und greet() sagt Bonjour.