Abschnitt 13 · Lektion 4
Interfaces
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
<?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
<?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
<?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
<?php
declare(strict_types=1);
// Diese Datei sagt eine Zusage zu und loest sie nur halb ein:
// anzahl() fehlt.
class HalbeAusgabe implements Ausgabe
{
public function zeile(string $text): void
{
}
} <?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, kostenlosZu 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.