Skip to content

6. Interfaces

Ein Interface ist eine Struktur, die Methodenprototypen definiert. Eine Klasse, die ein Interface implementiert, muss den Code für alle Methoden des Interfaces implementieren. Ein Interface ist ein Vertrag: Es legt fest, was ein Objekt kann, ohne festzulegen, wie es das tut.

6.1. Die Verzeichnisstruktur der Skripte

Die Skripte dieses Kapitels befinden sich im Ordner [scripts-console/interfaces]:

1
2
3
4
5
6
7
8
php8-oct-2026/scripts-console/interfaces
├── ICalculation.php
├── IExample.php
├── IExample2.php
├── interface-01.php
├── interface-02.php
├── interface-03.php
└── interface-04.php

6.2. Ein erstes Interface

Wir definieren ein Interface namens [IExample] in einem Skript namens [IExample.php]. Im selben Skript definieren wir zwei Klassen, die das Interface [IExample] implementieren:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter
declare(strict_types=1);

// Namespace
namespace Examples;

// eine Schnittstelle
interface IExample
{
    // die Methoden der Schnittstelle
    public function add(int $i, int $j): int;

    public function subtract(int $i, int $j): int;
}

// Implementierung 1 der Schnittstelle IExample
class Class1 implements IExample
{
    public function add(int $a, int $b): int
    {
        return $a + $b + 10;
    }

    public function subtract(int $a, int $b): int
    {
        return $a - $b + 20;
    }
}

// Implementierung 2 der Schnittstelle IExample
class Class2 implements IExample
{
    public function add(int $a, int $b): int
    {
        return $a + $b + 100;
    }

    public function subtract(int $a, int $b): int
    {
        return $a - $b + 200;
    }
}

Erläuterungen

  • Zeilen 10–15: Das Interface [IExample] definiert zwei Methoden: die Funktion [add] (Zeile 13) und die Funktion [subtract] (Zeile 15). Das Interface definiert den Code dieser Methoden nicht. Das übernehmen die Klassen, die das Interface implementieren. Die Methoden eines Interfaces müssen öffentlich sein;
  • Zeile 19: Die Klasse [Class1] implementiert ([implements]) das Interface [IExample]. Sie definiert daher Code für die Methoden [add] (Zeile 21) und [subtract] (Zeile 26). Die Parameternamen dürfen von denen im Interface abweichen ([$a] statt [$i]), ihre Typen müssen aber kompatibel sein. Beachten Sie jedoch: Mit den benannten Argumenten von PHP 8 würde ein Aufruf [add(i: 1, j: 2)] mit [Class1] nicht funktionieren. Es ist daher vorzuziehen, die Namen des Interfaces beizubehalten;
  • Zeilen 33–44: Dasselbe gilt für die Klasse [Class2].

Wir verwenden das Interface [IExample] im folgenden Skript [interface-01.php]:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter
declare(strict_types=1);

// Einbindung und Deklaration der vom Skript verwendeten Klassen und Schnittstellen
require_once __DIR__ . "/IExample.php";
use Examples\Class1;
use Examples\Class2;
use Examples\IExample;

// Funktion
function calculate(int $a, int $b, IExample $interface): void
{
    print $interface->add($a, $b) . "\n";
    print $interface->subtract($a, $b) . "\n";
}

// ------------------- main
// Erzeugen von 2 Objekten vom Typ Class1 und Class2
$c1 = new Class1();
$c2 = new Class2();
// Aufruf der Funktion calculate
calculate(4, 3, $c1);
calculate(14, 13, $c2);
// eine Schnittstelle kann nicht instanziiert werden
try {
    new IExample();
} catch (\Error $e) {
    print "Error: " . $e->getMessage() . "\n";
}

Ergebnisse:

1
2
3
4
5
6
> php interface-01.php
17
21
127
201
Error: Cannot instantiate interface Examples\IExample

Erläuterungen

  • Zeilen 7–10: Einbindung und Deklaration der vom Skript verwendeten Klassen und Interfaces. Die Datei [IExample.php] wird mit der Anweisung [require_once] eingebunden: Sie wird nur einmal eingebunden, auch wenn mehrere Skripte des Projekts sie einbinden;
  • Zeilen 13–17: Eine Funktion wird definiert;
  • Zeile 13: Hier haben wir die Typen der drei Parameter deklariert. Entspricht der tatsächliche Parameter zur Laufzeit nicht dem erwarteten Typ, wird ein Fehler [TypeError] ausgelöst. Der dritte Parameter hat den Typ [IExample]. Das bedeutet, dass der tatsächliche Parameter eine Instanz einer Klasse sein muss, die das Interface [IExample] implementiert; in unserem Beispiel also eine Instanz der Klassen [Class1] oder [Class2]. Die Funktion [calculate] kennt diese Klassen nicht; sie kennt nur das Interface. Wir können ihr Objekte später geschriebener Klassen übergeben, sofern sie das Interface [IExample] implementieren;
  • Zeilen 15–16: Wir verwenden die Methoden [add, subtract] des Interfaces [IExample];
  • Zeile 24: Der dritte tatsächliche Parameter hat den Typ [Class1], der mit dem Typ [IExample] des dritten formalen Parameters der Funktion kompatibel ist;
  • Zeile 25: Dasselbe gilt für die Klasse [Class2];
  • Zeile 28: Ein Interface kann nicht instanziiert werden; es wird ein Fehler zurückgegeben (Zeile 6 der Ergebnisse).

6.3. Ableiten eines Interfaces

Ebenso wie eine Kindklasse eine Elternklasse erweitern kann, kann ein Kind-Interface ein Eltern-Interface erweitern.

Betrachten Sie das Interface [IExample2] , das in der Datei [IExample2.php] definiert ist:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter
declare(strict_types=1);

// Namespace
namespace Examples;

// Einbindung der Definition der Schnittstelle IExample
require_once __DIR__ . "/IExample.php";

// eine von IExample abgeleitete Schnittstelle
interface IExample2 extends IExample
{
    // die von der Schnittstelle hinzugefügte Methode
    public function multiply(int $i, int $j): int;
}

// Implementierung der Schnittstelle IExample2
class Class3 extends Class2 implements IExample2
{
    // [Override] prüft, dass die Methode in der Schnittstelle tatsächlich existiert
    #[\Override]
    public function multiply(int $a, int $b): int
    {
        return $a * $b;
    }
}

Erläuterungen

  • Zeile 7: Das Interface [IExample2] liegt im selben Namensraum wie das Interface [IExample];
  • Zeile 10: Die Definitionsdatei des Interfaces [IExample] wird eingebunden;
  • Zeilen 13–17: definieren das Interface [IExample2], das das Interface ([extends]) [IExample] erweitert und ihm eine neue Methode hinzufügt (Zeile 16). Ein Interface kann sogar mehrere Interfaces erweitern: [interface I3 extends I1, I2];
  • Zeilen 20–28: Die Klasse [Class3] erweitert die Klasse [Class2]. Da Letztere das Interface [IExample] implementiert, tut dies auch die Klasse [Class3]. Tatsächlich erbt [Class3] alle öffentlichen und geschützten Methoden der Klasse [Class2], einschließlich der Methoden [add] und [subtract] . Außerdem wird festgelegt, dass [Class3] das Interface [IExample2] implementiert. Als solche muss sie auch die Methode [multiply] implementieren, was [Class2] nicht tut. Das leisten die Zeilen 24–27;
  • Zeile 23: Ab PHP 8.3 gilt das im vorherigen Kapitel besprochene Attribut [#[\Override]] auch für eine Methode, die eine Interface-Methode implementiert. Würde die Methode [multiply] aus dem Interface [IExample2] verschwinden, würde PHP dies melden.

Das Interface [IExample2] wird vom folgenden Skript [interface-02.php] verwendet:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter
declare(strict_types=1);

// Einbindung und Deklaration der vom Skript benötigten Klassen und Schnittstellen
require_once __DIR__ . "/IExample2.php";
use Examples\IExample2;
use Examples\Class3;

// Funktion
function calculate(int $a, int $b, IExample2 $interface): void
{
    print $interface->add($a, $b) . "\n";
    print $interface->subtract($a, $b) . "\n";
    print $interface->multiply($a, $b) . "\n";
}

// ------------------- main
// Erzeugen von 1 Objekt vom Typ Class3, das IExample2 implementiert
$c3 = new Class3();
// Aufruf der Funktion calculate
calculate(4, 3, $c3);

Ergebnisse:

1
2
3
4
> php interface-02.php
107
201
12

Erläuterungen

  • Zeile 12: Der dritte Parameter der Funktion [calculate] hat den Typ [IExample2];
  • Zeilen 14–16: Die drei Methoden des Interfaces [IExample2] werden verwendet: die beiden von [IExample] geerbten und seine eigene;
  • Zeile 23: Die Funktion [calculate] wird mit einem Objekt vom Typ [Class3] als drittem Parameter aufgerufen, das [IExample2] implementiert (Zeile 21).

6.4. Übergabe eines Interfaces als Funktionsparameter

Wir haben im vorherigen Kapitel (im Abschnitt „Übergabe eines Objekts als Funktionsparameter“) gesehen, dass der tatsächliche Parameter ein Objekt des erwarteten Typs oder eines abgeleiteten Typs sein kann, wenn der erwartete Typ eines Funktionsparameters eine Klasse ist. Dasselbe gilt für Interfaces, wie das folgende Skript zeigt, [interface-03.php]:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter
declare(strict_types=1);

// Einbindung und Deklaration der vom Skript benötigten Klassen und Schnittstellen
require_once __DIR__ . "/IExample.php";
require_once __DIR__ . "/IExample2.php";
use Examples\IExample;
use Examples\IExample2;
use Examples\Class1;
use Examples\Class3;

// Funktion
function calculate(int $a, int $b, IExample $interface): void
{
    print $interface->add($a, $b) . "\n";
    print $interface->subtract($a, $b) . "\n";
}

// ------------------- main
// Erzeugen von 1 Objekt vom Typ Class3, das IExample2 und damit IExample implementiert
$c3 = new Class3();
// Aufruf der Funktion calculate
calculate(4, 3, $c3);
// der Operator [instanceof] prüft, ob ein Objekt eine Schnittstelle implementiert
foreach ([new Class1(), $c3] as $object) {
    print $object::class . ": IExample=" . var_export($object instanceof IExample, true)
        . ", IExample2=" . var_export($object instanceof IExample2, true) . "\n";
}
// die von der Klasse Class3 implementierten Schnittstellen
print_r(class_implements($c3));

Ergebnisse:

> php interface-03.php
107
201
Examples\Class1: IExample=true, IExample2=false
Examples\Class3: IExample=true, IExample2=true
Array
(
    [Examples\IExample] => Examples\IExample
    [Examples\IExample2] => Examples\IExample2
)

Erläuterungen

  • Zeile 15: Die Funktion [calculate] erwartet als dritten Parameter einen Typ [IExample]. Das bedeutet, dass der tatsächliche Parameter vom Typ [IExample] oder von einem abgeleiteten Typ sein kann;
  • Zeile 23: Ein Objekt [$c3] wird aus der Klasse [Class3] instanziiert, die das Interface [IExample2] implementiert, das seinerseits das Interface [IExample] erweitert. Letztlich implementiert [$c3] also das Interface [IExample];
  • Zeile 25: Die Funktion [calculate] wird mit dem Objekt [$c3] (vom Typ [Class3]) als drittem Parameter aufgerufen. Durch Klassenvererbung und Implementierungen haben wir gesehen, dass das Objekt [$c3] den Typ [IExample] implementiert. Wir können es daher als dritten Parameter verwenden;
  • Zeilen 27–30: Der Operator [instanceof] prüft, ob ein Objekt ein Interface implementiert. Ein Objekt vom Typ [Class1] implementiert [IExample] , aber nicht [IExample2] (Zeile 4 der Ergebnisse). Ein Objekt vom Typ [Class3] implementiert beide (Zeile 5);
  • Zeile 32: Die Funktion [class_implements] gibt die Liste der Interfaces zurück, die von einem Objekt oder einer Klasse direkt oder durch Vererbung implementiert werden (Zeilen 6–10 der Ergebnisse).

6.5. Interface-Konstanten, mehrere Interfaces und Intersection-Typen

Ein Interface kann auch Konstanten deklarieren, und eine Klasse kann mehrere Interfaces implementieren. Wir definieren zwei Interfaces, [ICalculation] und [INameable], und zwei Klassen, die sie implementieren, in der Datei [ICalculation.php]:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter
declare(strict_types=1);

// Namespace
namespace Examples;

// eine Schnittstelle kann Konstanten deklarieren
interface ICalculation
{
    // typisierte Konstante (PHP 8.3)
    public const int PRECISION = 2;

    public function calculate(float $a, float $b): float;
}

// eine zweite Schnittstelle
interface INameable
{
    public function getName(): string;
}

// eine Klasse kann mehrere Schnittstellen implementieren
final class Addition implements ICalculation, INameable
{
    #[\Override]
    public function calculate(float $a, float $b): float
    {
        return round($a + $b, self::PRECISION);
    }

    #[\Override]
    public function getName(): string
    {
        return "addition";
    }
}

final class Division implements ICalculation, INameable
{
    #[\Override]
    public function calculate(float $a, float $b): float
    {
        // [ICalculation::PRECISION] und [self::PRECISION] bezeichnen dieselbe Konstante
        return round($a / $b, ICalculation::PRECISION);
    }

    #[\Override]
    public function getName(): string
    {
        return "division";
    }
}

Erläuterungen

  • Zeile 13: Das Interface [ICalculation] deklariert eine Konstante. Alle Klassen, die das Interface implementieren, erben sie. Ab PHP 8.3 kann eine Klassen- oder Interface-Konstante typisiert werden (hier [int]);
  • Zeilen 19–22: Ein zweites Interface mit nur einer Methode;
  • Zeile 25: Die Klasse [Addition] implementiert beide Interfaces: Die Interface-Namen werden durch Kommas getrennt. Sie muss die Methoden beider definieren;
  • Zeile 30: Auf die vom Interface geerbte Konstante wird mit [self::PRECISION] zugegriffen. Die Funktion [round] rundet eine Zahl auf die angegebene Anzahl von Dezimalstellen;
  • Zeile 46: Auf die Konstante kann auch über den Interface-Namen verwiesen werden: [ICalculation::PRECISION].

Diese Interfaces werden vom Skript [interface-04.php] verwendet:

<?php

// strikte Einhaltung der deklarierten Typen der Funktionsparameter
declare(strict_types=1);

// Einbindung und Deklaration der vom Skript benötigten Klassen und Schnittstellen
require_once __DIR__ . "/ICalculation.php";
use Examples\ICalculation;
use Examples\INameable;
use Examples\Addition;
use Examples\Division;

// der Parameter [$calculation] hat einen Standardwert: ein mit [new] erzeugtes Objekt (PHP 8.1)
function execute(float $a, float $b, ICalculation $calculation = new Addition()): float
{
    return $calculation->calculate($a, $b);
}

// Intersection-Typ (PHP 8.1): [$operation] muss beide Schnittstellen implementieren
function display(float $a, float $b, ICalculation&INameable $operation): void
{
    print $operation->getName() . "($a, $b)=" . $operation->calculate($a, $b) . "\n";
}

// ------------------- main
// Konstante der Schnittstelle
print "precision: " . ICalculation::PRECISION . " decimal places\n";
// Standardwert des 3. Parameters
print "execute(1.234, 2.345)=" . execute(1.234, 2.345) . "\n";
// expliziter Parameter
print "execute(10, 3, new Division())=" . execute(10, 3, new Division()) . "\n";
// Intersection-Typ
display(10, 4, new Division());
display(10, 4, new Addition());
// die Klassen implementieren beide Schnittstellen
print_r(class_implements(Division::class));

Ergebnisse:

> php interface-04.php
precision: 2 decimal places
execute(1.234, 2.345)=3.58
execute(10, 3, new Division())=3.33
division(10, 4)=2.5
addition(10, 4)=14
Array
(
    [Examples\ICalculation] => Examples\ICalculation
    [Examples\INameable] => Examples\INameable
)

Erläuterungen

  • Zeile 14: Der dritte Parameter der Funktion [execute] hat den Typ [ICalculation] und einen Standardwert – ein mit [Addition]-Objekt, das mit [new] erzeugt wird. Bis PHP 8.0 konnte der Standardwert eines Parameters nur eine Konstante sein. Ab PHP 8.1 wird der Ausdruck [new] in Standardwerten von Parametern akzeptiert („new in initializers“), ebenso in den Argumenten von PHP-Attributen ([#[...]]), in statischen Variablen und in globalen Konstanten. Im Standardwert eines Klassenattributs bleibt er verboten. Das Objekt wird bei jedem Aufruf erzeugt, der den Parameter weglässt;
  • Zeile 20: Der Typ [ICalculation&INameable] ist ein Intersection-Typ (PHP 8.1): Der tatsächliche Parameter muss sowohl [ICalculation] als auch [INameable] implementieren. Die Funktion kann dann Methoden aus beiden Interfaces aufrufen. Dies ist nicht mit dem Union-Typ [ICalculation|INameable] (einer von beiden) zu verwechseln;
  • Zeile 27: Auf die Konstante kann von außen über den Interface-Namen zugegriffen werden (Zeile 2 der Ergebnisse);
  • Zeile 29: Der dritte Parameter wird weggelassen; es ist ein [Addition]-Objekt, das die Berechnung durchführt (Zeile 3);
  • Zeile 31: Ein [Division]-Objekt wird explizit übergeben (Zeile 4). Beachten Sie, dass die ganzen Zahlen 10 und 3 trotz der Deklaration [strict_types=1] für Parameter vom Typ [float] akzeptiert werden: Die Umwandlung eines ***[int] in ein [float]*** ist die einzige im strikten Modus erlaubte automatische Umwandlung;
  • Zeilen 33–34: Beide Klassen implementieren beide Interfaces; sie werden von der Funktion [display] akzeptiert (Zeilen 5–6);
  • Zeile 36: Die Schreibweise [Division::class] steht für den vollständigen Klassennamen, in diesem Fall [Examples\Division]. Die Funktion [class_implements] akzeptiert sowohl einen Klassennamen als auch ein Objekt.

Interfaces sind in PHP selbst allgegenwärtig. Zwei sind uns im vorherigen Kapitel bereits begegnet: [Stringable], das jede Klasse mit einer Methode [__toString] automatisch implementiert, und [JsonSerializable], mit dem Sie die JSON-Kodierung eines Objekts steuern können. Im nächsten Kapitel betrachten wir das Interface [Throwable], das von allen Fehlern und Ausnahmen implementiert wird. Auch eine Enumeration kann ein Interface implementieren. Schließlich werden wir später in diesem Kurs sehen, dass Interfaces die Grundlage der Schichtenarchitektur unserer Anwendungen bilden: Jede Schicht kennt nur das Interface der angrenzenden Schicht.