mitmario.dev

Interfaces

PHP Sandbox 3 Min Lesezeit 4 BeispieleLektion 4 von 6

Ein Einkaufszettel geht heute ins Terminal. Morgen soll er in eine Datei. Und in einem Test soll er gar nicht erscheinen, weil eine Ausgabe dort nur stört und niemand sie liest.

Mit Vererbung kommst du hier nicht weit. Eine Ausgabe ins Terminal und eine Liste im Arbeitsspeicher sind keine Varianten derselben Sache, und sie haben keine Zeile Code gemeinsam. Gemeinsam ist nur, was man von ihnen verlangen kann. Beide sollen eine Zeile annehmen und sagen, wie viele es waren.

Ein Interface schreibt die Bedienung auf

Eine Zusage ohne einen einzigen Rumpf
<?php

declare(strict_types=1);

interface Ausgabe
{
    // Kein Rumpf, nur die Ankuendigung. Und keine Sichtbarkeit
    // ausser public: eine Zusage, die niemand einloesen darf,
    // waere keine.
    public function zeile(string $text): void;

    public function anzahl(): int;
}

class TerminalAusgabe implements Ausgabe
{
    private int $geschrieben = 0;

    public function zeile(string $text): void
    {
        echo $text, "\n";
        $this->geschrieben++;
    }

    public function anzahl(): int
    {
        return $this->geschrieben;
    }
}

$aus = new TerminalAusgabe();
$aus->zeile("Einkauf für Samstag");
$aus->zeile("Milch, Brot, Äpfel");

echo $aus->anzahl(), " Zeilen geschrieben\n";

In interface Ausgabe steht, welche Methoden es gibt, mit welchen Parametern und welchem Rückgabetyp. Statt eines Rumpfs steht dort ein Semikolon. Es gibt keine Eigenschaften, keinen Code und nichts zu erben. Nur die Zusage.

Eine Klasse sagt mit implements zu, dass sie diese Liste erfüllt. PHP prüft das schon, wenn es die Klasse anlegt, und nicht erst beim Aufruf einer Methode.

Methoden in einem Interface sind immer public. Etwas anderes erlaubt PHP dort nicht, hinschreiben darf man das Wort trotzdem. Konstanten darf ein Interface enthalten, gewöhnliche Eigenschaften nicht.

Der Aufrufer kennt nur die Zusage

Zwei Umsetzungen, ein Aufrufer
<?php

declare(strict_types=1);

interface Ausgabe
{
    public function zeile(string $text): void;

    public function anzahl(): int;
}

class TerminalAusgabe implements Ausgabe
{
    private int $geschrieben = 0;

    public function zeile(string $text): void
    {
        echo $text, "\n";
        $this->geschrieben++;
    }

    public function anzahl(): int
    {
        return $this->geschrieben;
    }
}

class ListenAusgabe implements Ausgabe
{
    private array $zeilen = [];

    public function zeile(string $text): void
    {
        $this->zeilen[] = $text;
    }

    public function anzahl(): int
    {
        return count($this->zeilen);
    }
}

// Diese Funktion kennt nur die Zusage. Wohin die Zeilen wirklich
// gehen, sieht sie nie.
function einkaufszettel(Ausgabe $aus): void
{
    $aus->zeile("Milch");
    $aus->zeile("Brot");
    $aus->zeile("Äpfel");
}

foreach ([new TerminalAusgabe(), new ListenAusgabe()] as $aus) {
    einkaufszettel($aus);
    echo get_class($aus), " ist eine Ausgabe: ", $aus instanceof Ausgabe ? "ja" : "nein", "\n";
    echo get_class($aus), " hat ", $aus->anzahl(), " Zeilen gezählt\n";
}

einkaufszettel(Ausgabe $aus) nimmt die Zusage als Typ und keine Klasse. Deshalb arbeitet die Funktion mit beiden Ausgaben, und auch mit einer dritten, die es noch gar nicht gibt.

Ohne das Interface hätte einkaufszettel() wissen müssen, dass sie ins Terminal schreibt. Jetzt weiß sie nur, was eine Ausgabe können muss, und welche es ist, entscheidet der Code, der sie aufruft. Im Terminal stehen die drei Zeilen deshalb nur einmal, von der TerminalAusgabe. Die ListenAusgabe hat sie genauso bekommen und gezählt, aber nirgends hingeschrieben.

Ob ein Objekt eine Zusage erfüllt, fragt instanceof. Meistens erledigt das schon die Typangabe. Für eine Fallunterscheidung ist es trotzdem da.

Interface oder abstrakte Klasse

Zusage gegen Erbe
<?php

declare(strict_types=1);

interface Zaehlbar
{
    public function anzahl(): int;
}

interface Leerbar
{
    public function leeren(): void;
}

// Erben kann eine Klasse nur von einer Oberklasse. Zusagen darf
// sie beliebig viele geben.
class Korb implements Zaehlbar, Leerbar
{
    private array $waren = ["Apfel", "Birne"];

    public function anzahl(): int
    {
        return count($this->waren);
    }

    public function leeren(): void
    {
        $this->waren = [];
    }
}

$korb = new Korb();

echo "Vorher:  ", $korb->anzahl(), "\n";
$korb->leeren();
echo "Nachher: ", $korb->anzahl(), "\n";

foreach ([Zaehlbar::class, Leerbar::class] as $zusage) {
    echo $zusage, ": ", $korb instanceof $zusage ? "ja" : "nein", "\n";
}

Eine abstrakte Klasse gibt Code vor, ein Interface nur eine Zusage. Teilen zwei Varianten Code, nehme ich die abstrakte Klasse. Teilen sie nur die Bedienung, nehme ich das Interface.

Erben kann eine Klasse von einer einzigen Oberklasse, Zusagen geben darf sie dagegen beliebig viele. Manchmal ist die Frage damit schon entschieden. Im Beispiel ist der Korb zugleich Zaehlbar und Leerbar, und keine der beiden Zusagen weiß von der anderen. Zaehlbar::class in der Schleife ist der Name des Interfaces als Text.

Beides zusammen geht auch. Eine abstrakte Klasse kann ein Interface umsetzen und einen Teil davon schon erledigen.

Was PHP durchsetzt und was nicht

Wenn eine Methode fehlt
<?php

declare(strict_types=1);

interface Ausgabe
{
    public function zeile(string $text): void;

    public function anzahl(): int;
}

echo "Bis hierher läuft alles.\n";

// PHP prueft die Zusage beim Einlesen der Datei, nicht erst beim
// Aufruf. Deshalb kommt hinter dieser Zeile nichts mehr.
require __DIR__ . "/kaputt.php";

echo "Diese Zeile wird nie erreicht.\n";

Fehlt eine zugesagte Methode, bricht PHP ab, sobald es die Klasse anlegt. Von ihr ist dann noch keine Zeile gelaufen. Die Meldung fängt mit Class HalbeAusgabe contains 1 abstract method an und nennt am Ende die Methode, die fehlt, (Ausgabe::anzahl).

Für PHP ist eine angekündigte Methode ohne Rumpf abstrakt, und dabei ist es egal, ob sie aus einer abstrakten Klasse kommt oder aus einem Interface. In der Meldung stehen deshalb zwei Auswege. Du kannst die Klasse selbst abstrakt machen oder die fehlende Methode schreiben, und gemeint ist fast immer das Zweite.

Die Syntax der Datei ist dabei in Ordnung. php -l kaputt.php meldet No syntax errors detected in kaputt.php, und php index.php bricht trotzdem beim require ab.

Durchsetzen kann PHP nur Namen und Signatur. Ein Interface prüft nicht, ob die Methode auch tut, was ihr Name verspricht. Nichts hindert eine Klasse daran, zeile() zu haben und darin gar nichts zu tun. Was eine Methode leisten soll, steht im Namen und in den Tests.

In Abschnitt 17 wird eine Umsetzung, die nur im Arbeitsspeicher sammelt, zum Werkzeug für Tests. Damit lässt sich Code prüfen, ohne eine einzige Datei anzufassen, und am aufrufenden Code ändert sich dafür nichts.

In der Aufgabe bekommt ein fertiger Dateispeicher eine Zusage und einen zweiten Speicher daneben.

Zum Mitnehmen

Ein Interface listet nur Methoden mit Parametern und Rückgabetyp, ohne Code. Eine Funktion, die das Interface als Typ nimmt, arbeitet mit jeder Klasse, die es mit implements zusagt, und weiß nicht, welche gerade dran ist.

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 4 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe, dein Code läuft auf einem Server

    Öffnet sich mit dem Basis Konto.