mitmario.dev

Vererbung

PHP Sandbox 4 Min Lesezeit 5 BeispieleLektion 3 von 6

Kaffee und Tee unterscheiden sich in einer einzigen Methode. Der Konstruktor ist gleich, zeile() ist wortgleich, und beides steht zweimal da.

Dieselbe Methode in zwei Klassen

Zweimal dasselbe, nur der Preis ist anders
<?php

declare(strict_types=1);

class Kaffee
{
    public function __construct(
        private readonly string $name,
        private readonly int $tassen,
    ) {
    }

    public function preis(): int
    {
        return $this->tassen * 280;
    }

    public function zeile(): string
    {
        return $this->name . ": " . number_format($this->preis() / 100, 2, ",", ".");
    }
}

class Tee
{
    public function __construct(
        private readonly string $name,
        private readonly int $tassen,
    ) {
    }

    // Die erste Tasse kostet 2,20, jedes Nachgiessen 0,80.
    public function preis(): int
    {
        return 220 + ($this->tassen - 1) * 80;
    }

    // Wortgleich mit der Fassung oben. Wer hier etwas aendert,
    // muss daran denken, es zweimal zu tun.
    public function zeile(): string
    {
        return $this->name . ": " . number_format($this->preis() / 100, 2, ",", ".");
    }
}

echo (new Kaffee("Milchkaffee", 2))->zeile(), "\n";
echo (new Tee("Pfefferminztee", 3))->zeile(), "\n";

PHP achtet nicht darauf, dass beide Fassungen gleich bleiben. Änderst du morgen das Format der Zeile, erwischst du vielleicht nur eine der beiden Stellen. Das Programm gibt danach ohne jede Beschwerde zwei verschiedene Formate aus, denn für PHP sind das einfach zwei Methoden, die zufällig gleich aussehen.

extends zieht das Gemeinsame nach oben

Das Gemeinsame in einer Oberklasse
<?php

declare(strict_types=1);

abstract class Getraenk
{
    public function __construct(
        private readonly string $name,
        protected readonly int $tassen,
    ) {
    }

    abstract public function preis(): int;

    public function zeile(): string
    {
        return $this->name . ": " . number_format($this->preis() / 100, 2, ",", ".");
    }
}

class Kaffee extends Getraenk
{
    public function preis(): int
    {
        return $this->tassen * 280;
    }
}

class Tee extends Getraenk
{
    // Die erste Tasse kostet 2,20, jedes Nachgiessen 0,80.
    public function preis(): int
    {
        return 220 + ($this->tassen - 1) * 80;
    }
}

echo (new Kaffee("Milchkaffee", 2))->zeile(), "\n";
echo (new Tee("Pfefferminztee", 3))->zeile(), "\n";

class Kaffee extends Getraenk heißt, dass Kaffee alles hat, was Getraenk hat, und etwas dazutun darf. Das ist Vererbung (englisch inheritance). Getraenk ist die Oberklasse (parent class), Kaffee und Tee sind ihre Unterklassen (child classes). Der Konstruktor steht nur noch einmal da, zeile() ebenfalls. In den Unterklassen bleibt nur die Methode übrig, in der sie sich wirklich unterscheiden.

Methoden und Eigenschaften wandern nach unten, aber die Sichtbarkeit gilt weiter:

  • public und protected sind in der Unterklasse benutzbar.
  • Mit private geht das nicht. Eine Eigenschaft, die in Getraenk private ist, gibt es für Kaffee gar nicht. Ein Zugriff darauf meldet deshalb nichts über Sichtbarkeit, es kommt eine ganz gewöhnliche Warnung Undefined property.

Für diesen Fall gibt es protected, also „diese Klasse und alles, was von ihr erbt“. Im Beispiel ist $tassen protected, weil beide preis() damit rechnen. $name bleibt private, denn den braucht nur zeile() in der Oberklasse.

Im Reiter Debug stehen in zeile() noch $this->name und $this->tassen in der Liste. Einen Schritt weiter in Kaffee::preis() ist es nur noch $this->tassen.

Überschreiben und mit parent:: ergänzen

Mit parent ergänzen statt ersetzen
<?php

declare(strict_types=1);

class Kaffee
{
    public function __construct(protected readonly int $tassen)
    {
    }

    public function preis(): int
    {
        return $this->tassen * 280;
    }
}

class Cappuccino extends Kaffee
{
    public function __construct(int $tassen, private readonly bool $hafermilch)
    {
        parent::__construct($tassen);
    }

    // Nicht ersetzen, sondern draufrechnen: der Milchschaum je Tasse.
    public function preis(): int
    {
        return parent::preis() + $this->tassen * ($this->hafermilch ? 60 : 40);
    }
}

$kaffee = new Kaffee(2);
$cappuccino = new Cappuccino(2, true);

echo "Kaffee:     ", number_format($kaffee->preis() / 100, 2, ",", "."), "\n";
echo "Cappuccino: ", number_format($cappuccino->preis() / 100, 2, ",", "."), "\n";

Schreibt eine Unterklasse eine Methode noch einmal, die es oben schon gibt, gilt ihre Fassung. Das nennt man Überschreiben, und meistens ist es so gewollt.

Ein Cappuccino kostet aber den Kaffee plus den Milchschaum. Die Unterklasse ersetzt den Preis also nicht, sie ergänzt ihn. Dafür gibt es parent::. Damit ruft sie die Fassung der Oberklasse auf und rechnet mit deren Ergebnis weiter.

Beim Konstruktor ist es genauso. Braucht eine Unterklasse einen eigenen, ruft sie mit parent::__construct(...) den von oben auf. Fehlt diese Zeile, läuft der Konstruktor der Oberklasse gar nicht. Die geerbten Eigenschaften haben dann keinen Wert, und der erste Zugriff darauf bricht mit Typed property Kaffee::$tassen must not be accessed before initialization ab. Das ist derselbe Fehler wie beim halbfertigen Objekt aus Lektion 13.1.

Eine Klasse, von der es kein Objekt gibt

Ein Bauplan ohne Haus
<?php

declare(strict_types=1);

abstract class Getraenk
{
    // Kein Rumpf, nur ein Semikolon: jede Sorte muss das
    // selbst wissen.
    abstract public function preis(): int;
}

class Kaffee extends Getraenk
{
    public function preis(): int
    {
        return 280;
    }
}

echo "Kaffee: ", number_format((new Kaffee())->preis() / 100, 2, ",", "."), "\n";

try {
    new Getraenk();
} catch (Error $fehler) {
    echo "Abgelehnt: ", $fehler->getMessage(), "\n";
}

abstract class Getraenk heißt, dass diese Klasse nur zum Erben da ist. new Getraenk() ist ein Error mit der Meldung Cannot instantiate abstract class Getraenk. Ein Getränk, bei dem keiner weiß, welches, hätte ja auch keinen Preis.

abstract public function preis(): int; ist eine Methode ohne Rumpf, nur mit Semikolon. Gemeint ist damit „das muss jede Variante selbst wissen“, und PHP besteht darauf. Eine Unterklasse ohne diese Methode lässt sich nicht einmal einlesen.

Eine Methode oben, zwei Ergebnisse

Zwei Getränke als Preisliste
<?php

declare(strict_types=1);

abstract class Getraenk
{
    public function __construct(
        private readonly string $name,
        protected readonly int $tassen,
    ) {
    }

    abstract public function preis(): int;

    // Eine Methode in der Oberklasse, zwei Ergebnisse: preis()
    // kommt jeweils aus der Unterklasse.
    public function reihe(): string
    {
        return "<tr><td>" . htmlspecialchars($this->name, ENT_QUOTES, "UTF-8")
            . "</td><td>" . $this->tassen . "</td><td>"
            . number_format($this->preis() / 100, 2, ",", ".") . " Euro</td></tr>";
    }
}

class Kaffee extends Getraenk
{
    public function preis(): int
    {
        return $this->tassen * 280;
    }
}

class Tee extends Getraenk
{
    public function preis(): int
    {
        return 220 + ($this->tassen - 1) * 80;
    }
}

echo "<!DOCTYPE html>\n";
echo "<html lang=\"de\">\n<head>\n<meta charset=\"utf-8\">\n<title>Getränke</title>\n";
// Das Aussehen steht der Kuerze halber gleich im Kopf der Seite.
echo "<style>body{font-family:system-ui;margin:1rem}";
echo "table{border-collapse:collapse}";
echo "td,th{border:1px solid #999;padding:.35rem .6rem;text-align:left}</style>\n";
echo "</head>\n<body>\n<h1>Getränke</h1>\n";
echo "<table><tr><th>Getränk</th><th>Tassen</th><th>Preis</th></tr>\n";

foreach ([new Kaffee("Milchkaffee", 2), new Tee("Pfefferminztee", 3)] as $getraenk) {
    echo $getraenk->reihe(), "\n";
}

echo "</table>\n</body>\n</html>\n";

Ausnahmsweise läuft hier ein Server, und im Reiter Browser steht eine kleine Preisliste.

reihe() steht ein einziges Mal in der Oberklasse und liefert trotzdem für Kaffee und Tee verschiedene Zeilen, weil $this->preis() jeweils die Fassung der Unterklasse aufruft.

Wann Vererbung passt, und wann nicht

Vererbung passt, wenn zwei Klassen dieselbe Sache in Varianten sind. Ein Kaffee ist ein Getränk, ein Tee ist ein Getränk. Zur Probe sagst du den Satz „ein X ist ein Y“. Klingt er falsch, passt auch die Vererbung nicht.

Sie passt nicht, wenn zwei Dinge sich nur ähneln oder wenn eine Klasse etwas hat, statt etwas zu sein. Eine Bestellung hat eine Adresse, sie ist keine. Also bekommt sie die Adresse als Objekt in den Konstruktor und erbt nichts von ihr.

Ich bleibe in diesem Kurs bei einer Ebene. Drei oder vier Stufen sind schnell gebaut, und danach rätst du beim Lesen jeder Methode, aus welcher der vier Klassen sie eigentlich kommt. In der nächsten Lektion arbeiten Klassen zusammen, ohne dass eine von der anderen erbt.

In der Aufgabe wandern bei Brief und Paket der gemeinsame Konstruktor und die gemeinsame Methode nach oben.

Zum Mitnehmen

Vererbung zieht das Gemeinsame zweier Klassen in eine Oberklasse, und jede Unterklasse schreibt nur noch, was sie anders macht. private bleibt oben, protected reicht nach unten, und abstract verlangt eine Methode von jeder Variante.

Jetzt du

Basis Konto, kostenlos

Zu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.

Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.

In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.

Was in dieser Lektion steckt

  • Artikel mit 5 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe, dein Code läuft auf einem Server

    Öffnet sich mit dem Basis Konto.