interface

Das PHP-Schlüsselwort interface

Ein Interface ist ein Vertrag: Es listet die Methoden auf, die eine Klasse bereitstellen muss, ohne festzulegen, wie sie funktionieren. Jede Klasse, die ein Interface mit implements übernimmt, verpflichtet sich dazu, jede darin deklarierte Methode zu definieren. So können Sie gegen eine Fähigkeit programmieren („alles, was protokolliert werden kann", „alles, was serialisiert werden kann") statt gegen eine konkrete Klasse.

Interfaces können nicht direkt instanziiert werden — es gibt keine Implementierung, die ausgeführt werden könnte. Sie existieren, damit nicht verwandte Klassen austauschbar behandelt werden können, solange sie dieselben Methodensignaturen teilen.

Diese Seite erklärt, wie Sie ein Interface deklarieren, eines oder mehrere implementieren, Konstanten teilen, Interfaces erweitern und Typen zur Laufzeit mit instanceof prüfen. Wenn Sie neu im Umgang mit Objekten in PHP sind, beginnen Sie mit PHP-Klassen und Objekte und Was ist OOP.

Syntax

Hier ist die grundlegende Syntax zum Deklarieren eines Interfaces:

interface MyInterface {
  public function someMethod();
}

Dies deklariert ein Interface MyInterface mit einer einzelnen Methode someMethod(). Wichtige Regeln:

• Methodenkörper werden weggelassen — ein Interface deklariert nur Signaturen, jede endet mit einem Semikolon.
• Alle Methoden sind implizit public; Sie können public zur Klarheit schreiben, aber keine andere Sichtbarkeit ist erlaubt (private/protected sind verboten).
• Eine Klasse übernimmt ein Interface mit dem Schlüsselwort implements und muss jede Methode definieren, sonst löst PHP einen fatalen Fehler aus.

Beispiele

Betrachten wir einige praktische Beispiele, wie das Schlüsselwort interface verwendet werden kann. Die erste Klasse implementiert ein Interface; die zweite implementiert gleichzeitig zwei (durch Kommas getrennt):

<?php

// Example 1
interface MyInterface {
  public function someMethod();
}
class MyClass implements MyInterface {
  public function someMethod() {
    echo "This is from someMethod." . PHP_EOL;
  }
}

$obj = new MyClass();
$obj->someMethod();

// Output: This is from someMethod.

// Example 2
interface MyOtherInterface {
  public function someOtherMethod();
}
class MyOtherClass implements MyInterface, MyOtherInterface {
  public function someMethod() {
    echo "This is from someMethod." . PHP_EOL;
  }
  public function someOtherMethod() {
    echo "This is from someOtherMethod." . PHP_EOL;
  }
}

$obj2 = new MyOtherClass();
$obj2->someMethod();
$obj2->someOtherMethod();

// Output:
// This is from someMethod.
// This is from someOtherMethod.

In diesen Beispielen definieren wir Interfaces und verwenden sie in unseren PHP-Klassen, um sicherzustellen, dass unsere Klassen die erforderlichen Methoden implementieren.

Interface-Konstanten

Ein Interface kann Konstanten deklarieren, die jede implementierende Klasse erbt. Sie sind immer public und können nicht überschrieben werden, was sie nützlich für gemeinsam genutzte, unveränderliche Werte macht:

<?php

interface HttpStatus {
  const OK = 200;
  const NOT_FOUND = 404;
}

class Response implements HttpStatus {
  public function describe(): string {
    return "Status " . self::OK;
  }
}

echo (new Response())->describe() . PHP_EOL;
echo HttpStatus::NOT_FOUND . PHP_EOL;

// Output:
// Status 200
// 404

Für Konstanten, die überschrieben werden können, verwenden Sie stattdessen Klassenkonstanten innerhalb einer Klasse.

Interfaces erweitern

Anders als Klassen kann ein Interface mehrere andere Interfaces mit extend erweitern. Das kombinierte Interface erfordert dann alle Methoden von jedem übergeordneten Interface:

<?php

interface Readable {
  public function read(): string;
}

interface Writable {
  public function write(string $data): void;
}

// A single interface that demands both capabilities
interface ReadWrite extends Readable, Writable {}

class File implements ReadWrite {
  private string $buffer = "";
  public function read(): string { return $this->buffer; }
  public function write(string $data): void { $this->buffer = $data; }
}

$f = new File();
$f->write("hello");
echo $f->read() . PHP_EOL;

// Output: hello

So simuliert PHP Mehrfachvererbung — siehe PHP-Vererbung für einfache Klassenvererbung mit extends.

Typhinweise und instanceof

Da jede implementierende Klasse das Interface erfüllt, können Sie das Interface in Funktionssignaturen als Typhinweis verwenden und beliebige passende Objekte akzeptieren. Verwenden Sie instanceof, um zur Laufzeit zu prüfen:

<?php

interface Shape {
  public function area(): float;
}

class Circle implements Shape {
  public function __construct(private float $r) {}
  public function area(): float { return 3.14159 * $this->r ** 2; }
}

function printArea(Shape $shape): void {
  echo round($shape->area(), 2) . PHP_EOL;
}

$c = new Circle(2);
printArea($c);
var_dump($c instanceof Shape);

// Output:
// 12.57
// bool(true)

Interface vs. abstrakte Klasse

Beide definieren einen Vertrag, lösen aber unterschiedliche Probleme:

• Ein Interface deklariert nur Methodensignaturen und eine Klasse kann viele davon implementieren. Verwenden Sie es, um eine Fähigkeit zu beschreiben, die von nicht verwandten Klassen geteilt wird.
• Eine abstrakte Klasse kann sowohl konkrete Methoden und Eigenschaften als auch abstrakte bereitstellen, aber eine Klasse kann nur eine erweitern. Verwenden Sie sie, um Implementierung unter verwandten Klassen zu teilen.

Wenn Sie Code klassenübergreifend teilen müssen, ohne Vererbung zu nutzen, greifen Sie auf Traits zurück.

Vorteile

Die Verwendung des Schlüsselworts „interface" bietet mehrere Vorteile, darunter:

• Entkopplung und Flexibilität: Interfaces ermöglichen es Ihnen, Implementierungen auszutauschen, ohne abhängigen Code zu ändern, was Ihr System anpassungsfähiger macht.
• Einfacheres Testen: Sie ermöglichen Mocking und Stubbing, was Unit-Tests und Debugging vereinfacht.
• Simulation von Mehrfachvererbung: Da PHP keine mehrfache Klassenvererbung unterstützt, kann eine Klasse mehrere Interfaces implementieren, um Verhaltensverträge aus verschiedenen Quellen zu erben.

Fazit

Das Schlüsselwort interface ermöglicht es Ihnen, einen Vertrag erforderlicher Methoden zu definieren, den jede Klasse implementieren kann, unabhängig von ihrer Position in der Klassenhierarchie. In Kombination mit Typhinweisen und instanceof machen Interfaces Code flexibler, testbarer und entkoppelter. Greifen Sie auf ein Interface zurück, wenn Sie eine Fähigkeit beschreiben möchten; greifen Sie auf eine abstrakte Klasse zurück, wenn Sie auch Implementierung teilen möchten.

Übungen