Polymorphismus über Interfaces

Teil des Abschnitts Objektorientierte Programmierung der PHP-Journey von Coddy — Lektion 34 von 91.

In der vorherigen Lektion haben Sie Polymorphismus durch Vererbung kennengelernt, bei dem Kindklassen Methoden der Elternklassen überschreiben. Interfaces bieten eine weitere leistungsstarke Möglichkeit, Polymorphismus zu erreichen, insbesondere bei der Arbeit mit nicht verwandten Klassen, die gemeinsames Verhalten teilen.

Bei Interfaces ergibt sich der Polymorphismus aus dem Vertrag selbst. Jede Klasse, die ein Interface implementiert, garantiert, dass sie über bestimmte Methoden verfügt, unabhängig von ihrer Vererbungshierarchie:

<?php
interface Notifiable {
    public function send(string $message);
}

class EmailNotifier implements Notifiable {
    public function send(string $message) {
        return "Email: " . $message;
    }
}

class SMSNotifier implements Notifiable {
    public function send(string $message) {
        return "SMS: " . $message;
    }
}

class PushNotifier implements Notifiable {
    public function send(string $message) {
        return "Push: " . $message;
    }
}

function notify(Notifiable $notifier, string $message) {
    return $notifier->send($message);
}

echo notify(new EmailNotifier(), "Hello") . "\n";
echo notify(new SMSNotifier(), "Hello") . "\n";
echo notify(new PushNotifier(), "Hello");

Ausgabe:

Email: Hello
SMS: Hello
Push: Hello

Die Funktion notify() arbeitet mit jedem Notifiable-Objekt. Diese Klassen teilen keine gemeinsame Elternklasse – sie stehen in keinerlei Beziehung zueinander, außer dass sie dasselbe Interface implementieren. Dies ist der entscheidende Vorteil gegenüber vererbungsbasierter Polymorphie: Sie können nicht verwandte Klassen nach ihren Fähigkeiten gruppieren, anstatt nach ihrer Abstammung.

Kernpunkt: Interface-basierte Polymorphie ermöglicht es, nicht verwandte Klassen basierend auf gemeinsamem Verhalten austauschbar zu verwenden, wodurch Ihr Code flexibler und von spezifischen Implementierungen entkoppelt wird.

Aufgabe

Einfach

Lassen Sie uns ein Speichersystem bauen, das Interface-basierte Polymorphie demonstriert. Sie werden verschiedene Speicher-Backends erstellen — ein Dateisystem und eine Datenbank —, die nichts gemeinsam haben, außer dass sie beide dasselbe Storage-Interface implementieren. Eine einzige Funktion wird mit jedem Speichertyp funktionieren und zeigen, wie Interfaces Polymorphie zwischen völlig unabhängigen Klassen ermöglichen.

Sie werden Ihren Code über vier Dateien organisieren:

Storable.php — Definieren Sie ein Storable Interface mit zwei Methodensignaturen: save($key, $data) und retrieve($key). Dieser Vertrag stellt sicher, dass jedes Speichersystem Daten speichern und abrufen kann, unabhängig davon, wie es intern implementiert ist.
FileStorage.php — Erstellen Sie eine FileStorage Klasse, die Storable implementiert. Binden Sie die Interface-Datei ein. Die Klasse sollte eine private $directory Eigenschaft haben, die über den Konstruktor gesetzt wird. Implementieren Sie save($key, $data) so, dass es "Saving '$data' to file $this->directory/$key.txt" zurückgibt. Implementieren Sie retrieve($key) so, dass es "Reading from file $this->directory/$key.txt" zurückgibt.
DatabaseStorage.php — Erstellen Sie eine DatabaseStorage Klasse, die ebenfalls Storable implementiert. Binden Sie die Interface-Datei ein. Die Klasse sollte eine private $tableName Eigenschaft haben, die über den Konstruktor gesetzt wird. Implementieren Sie save($key, $data) so, dass es "Inserting '$data' into table $this->tableName with key $key" zurückgibt. Implementieren Sie retrieve($key) so, dass es "Selecting from table $this->tableName where key = $key" zurückgibt.
main.php — Binden Sie beide Speicher-Dateien ein. Erstellen Sie eine Funktion namens storeData, die einen Storable Parameter, einen Key und Daten akzeptiert. Die Funktion sollte das Ergebnis des Aufrufs von save() mit dem Key und den Daten zurückgeben. Erstellen Sie eine weitere Funktion namens fetchData, die einen Storable Parameter und einen Key akzeptiert und das Ergebnis des Aufrufs von retrieve() zurückgibt.

Sie erhalten vier Eingaben: einen Verzeichnispfad, einen Tabellennamen, einen Key und einige zu speichernde Daten. Erstellen Sie ein FileStorage Objekt mit dem Verzeichnis und ein DatabaseStorage Objekt mit dem Tabellennamen. Verwenden Sie Ihre storeData() Funktion, um die Daten zuerst mit dem Dateispeicher und dann mit dem Datenbankspeicher zu speichern. Geben Sie jedes Ergebnis in einer eigenen Zeile aus. Verwenden Sie dann fetchData(), um Daten aus dem Dateispeicher abzurufen, und geben Sie dieses Ergebnis aus.

Beachten Sie, wie storeData() und fetchData() mit beiden Speichertypen identisch funktionieren — es ist ihnen nur wichtig, dass das Objekt Storable implementiert. Das Dateisystem und die Datenbank haben völlig unterschiedliche interne Implementierungen, sind aber durch den Interface-Vertrag austauschbar.

Spickzettel

Schnittstellen ermöglichen Polymorphismus, indem sie es erlauben, nicht verwandte Klassen basierend auf gemeinsamem Verhalten anstatt auf einer Vererbungshierarchie austauschbar zu verwenden.

Jede Klasse, die eine Schnittstelle implementiert, garantiert, dass sie über bestimmte Methoden verfügt, wodurch ein Vertrag entsteht, der polymorphes Verhalten ermöglicht:

<?php
interface Notifiable {
    public function send(string $message);
}

class EmailNotifier implements Notifiable {
    public function send(string $message) {
        return "Email: " . $message;
    }
}

class SMSNotifier implements Notifiable {
    public function send(string $message) {
        return "SMS: " . $message;
    }
}

function notify(Notifiable $notifier, string $message) {
    return $notifier->send($message);
}

echo notify(new EmailNotifier(), "Hello");
echo notify(new SMSNotifier(), "Hello");

Die Funktion notify() akzeptiert jedes Objekt, das Notifiable implementiert, unabhängig von der Klassenhierarchie. Dies macht den Code flexibler und entkoppelt ihn von spezifischen Implementierungen.

Hauptvorteil: Schnittstellenbasierter Polymorphismus gruppiert nicht verwandte Klassen nach ihren Fähigkeiten, nicht nach ihrer Abstammung, wodurch völlig unterschiedliche Implementierungen durch einen gemeinsamen Vertrag austauschbar verwendet werden können.

Probier es selbst

<?php
require_once 'FileStorage.php';
require_once 'DatabaseStorage.php';

// Eingaben lesen
$directory = trim(fgets(STDIN));
$tableName = trim(fgets(STDIN));
$key = trim(fgets(STDIN));
$data = trim(fgets(STDIN));

// TODO: Erstellen Sie eine Funktion storeData, die ein Storable, einen Schlüssel und Daten akzeptiert
// Sie sollte das Ergebnis des Aufrufs von save() mit dem Schlüssel und den Daten zurückgeben

// TODO: Erstellen Sie eine Funktion fetchData, die ein Storable und einen Schlüssel akzeptiert
// Sie sollte das Ergebnis des Aufrufs von retrieve() mit dem Schlüssel zurückgeben

// TODO: Erstellen Sie eine FileStorage-Instanz mit dem Verzeichnis

// TODO: Erstellen Sie eine DatabaseStorage-Instanz mit dem Tabellennamen

// TODO: Verwenden Sie storeData(), um Daten mit dem Dateispeicher zu speichern, und geben Sie dann das Ergebnis aus

// TODO: Verwenden Sie storeData(), um Daten mit dem Datenbankspeicher zu speichern, und geben Sie dann das Ergebnis aus

// TODO: Verwenden Sie fetchData(), um Daten aus dem Dateispeicher abzurufen, und geben Sie dann das Ergebnis aus
?>