PHP Interface: implements, Konstanten und Beispiele

Ein PHP-Interface deklariert Methoden, die eine Klasse bereitzustellen verspricht, ganz ohne Code: interface Shape { public function area(): float; }. Eine Klasse, die implements Shape schreibt, muss area() definieren, und jede Funktion mit der Typangabe Shape akzeptiert diese Klasse.

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

class Square implements Shape
{
    public function __construct(private float $side) {}

    public function area(): float
    {
        return $this->side ** 2;
    }
}

class Circle implements Shape
{
    public function __construct(private float $r) {}

    public function area(): float
    {
        return round(M_PI * $this->r ** 2, 2);
    }
}

function describe(Shape $s): string
{
    return get_class($s) . ' with area ' . $s->area();
}

echo describe(new Square(3)), "\n";
echo describe(new Circle(2)), "\n";
var_dump(new Circle(1) instanceof Shape);

describe() weiß nicht, welche Klasse es bekommt, und es ist ihm egal. Es verlässt sich nur auf das Versprechen des Interfaces, also funktioniert ein neues Triangle implements Shape damit, ohne dass sich eine Zeile ändert.

Gegen ein Interface programmieren

Der übliche Grund für ein Interface ist, Code von einer Fähigkeit abhängig zu machen statt von einer bestimmten Klasse. Hier akzeptiert ein Bestellservice jeden Notifier, sodass derselbe Code in Produktion E-Mails verschicken und in einem Test Nachrichten sammeln kann:

<?php
interface Notifier
{
    public function send(string $to, string $message): bool;
}

class EmailNotifier implements Notifier
{
    public function send(string $to, string $message): bool
    {
        echo "Email to $to: $message\n";
        return true;
    }
}

class FakeNotifier implements Notifier
{
    public array $sent = [];

    public function send(string $to, string $message): bool
    {
        $this->sent[] = [$to, $message];
        return true;
    }
}

class OrderService
{
    public function __construct(private Notifier $notifier) {}

    public function place(string $customer, int $orderId): void
    {
        $this->notifier->send($customer, "Order #$orderId confirmed");
    }
}

(new OrderService(new EmailNotifier()))->place('ada@example.com', 1001);

$fake = new FakeNotifier();
(new OrderService($fake))->place('linus@example.com', 1002);
print_r($fake->sent);

Mehrere Interfaces implementieren

Eine Klasse erweitert höchstens eine Elternklasse, kann aber so viele Interfaces implementieren, wie sie braucht. Führe sie nach implements auf, durch Kommas getrennt, und definiere die Methoden aller:

<?php
interface HasName
{
    public function name(): string;
}

interface Exportable
{
    public function toArray(): array;
}

class Product implements HasName, Exportable, JsonSerializable
{
    public function __construct(private string $title, private int $priceCents) {}

    public function name(): string
    {
        return $this->title;
    }

    public function toArray(): array
    {
        return ['title' => $this->title, 'price' => $this->priceCents / 100];
    }

    public function jsonSerialize(): array
    {
        return $this->toArray();
    }
}

$p = new Product('Desk lamp', 3490);
echo $p->name(), "\n";
print_r($p->toArray());
echo json_encode($p), "\n";
print_r(class_implements($p));

JsonSerializable ist eines der eingebauten Interfaces von PHP: Wer es implementiert, bestimmt, was json_encode() für das Objekt erzeugt.

Interface-Konstanten

Ein Interface kann Konstanten deklarieren. Jede implementierende Klasse erbt sie, und du kannst sie über den Interface-Namen oder den Klassennamen lesen:

<?php
interface HttpStatus
{
    const OK = 200;
    const NOT_FOUND = 404;
}

class Response implements HttpStatus
{
    public function __construct(public int $status = self::OK) {}

    public function isError(): bool
    {
        return $this->status >= 400;
    }
}

echo HttpStatus::NOT_FOUND, "\n";
echo Response::OK, "\n";

$r = new Response(Response::NOT_FOUND);
var_dump($r->isError());

Interfaces können in PHP 8.3 keine Eigenschaften haben, nur Methoden und Konstanten. Die Methoden dürfen statisch sein: public static function fromArray(array $data): static; im Interface verpflichtet jede Klasse, diese statische Methode zu definieren. Für eine feste Menge zusammengehöriger Werte passt ein Enum oft besser als eine Liste von Interface-Konstanten.

Ein Interface kann andere Interfaces erweitern

Auch Interfaces verwenden extends, und anders als Klassen können sie mehrere auf einmal erweitern. Eine Klasse, die das Kind-Interface implementiert, muss die Methoden der ganzen Kette definieren:

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

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

interface Stream extends Readable, Writable
{
    public function close(): void;
}

class MemoryStream implements Stream
{
    private string $buffer = '';

    public function read(): string { return $this->buffer; }
    public function write(string $data): void { $this->buffer .= $data; }
    public function close(): void { $this->buffer = ''; }
}

$s = new MemoryStream();
$s->write('Hello, ');
$s->write('stream');
echo $s->read(), "\n";
var_dump($s instanceof Readable, $s instanceof Writable);

Eingebaute Interfaces: Countable, IteratorAggregate, Stringable

PHP bringt Interfaces mit, die Objekte an die Sprache anbinden. Countable lässt count($obj) funktionieren, IteratorAggregate lässt foreach funktionieren, und Stringable wird automatisch von jeder Klasse mit einer Methode __toString() implementiert:

<?php
class Playlist implements Countable, IteratorAggregate
{
    private array $songs = [];

    public function add(string $song): static
    {
        $this->songs[] = $song;
        return $this;
    }

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

    public function getIterator(): Iterator
    {
        return new ArrayIterator($this->songs);
    }

    public function __toString(): string
    {
        return implode(' / ', $this->songs);
    }
}

$list = (new Playlist())->add('Intro')->add('Blue')->add('Outro');

echo count($list), " songs\n";
foreach ($list as $i => $song) {
    echo "$i: $song\n";
}
var_dump($list instanceof Stringable);
echo "$list\n";

Eine Methode vergessen

Wenn eine Klasse behauptet, ein Interface zu implementieren, aber eine Methode fehlt, stoppt PHP mit einem fatalen Fehler, der die fehlende Methode nennt:

<?php
// This fails on purpose: Invoice does not define total()
interface Billable
{
    public function total(): float;
    public function currency(): string;
}

class Invoice implements Billable
{
    public function currency(): string
    {
        return 'EUR';
    }
}

echo (new Invoice())->currency();

Füge eine Methode total() hinzu, und das Skript läuft. Eine abstrakte Klasse darf Interface-Methoden undefiniert lassen, und genau diesen Ausweg schlägt die Fehlermeldung vor.

Interface vs abstrakte Klasse

Beide definieren Methoden, die eine Klasse haben muss, und beide lassen sich als Typangabe verwenden. Der Unterschied liegt darin, was sie sonst enthalten dürfen und wie viele eine Klasse verwenden kann:

Sie lassen sich gut kombinieren: Definiere das Interface für die Typangabe und biete eine abstrakte Basisklasse an, die es mit dem gemeinsamen Code implementiert. Klassen, die eine andere Basis brauchen, können das Interface trotzdem direkt implementieren.