Interfejsy w PHP: implements, stałe i przykłady

Interfejs w PHP deklaruje metody, które klasa obiecuje zapewnić, bez żadnego kodu: interface Shape { public function area(): float; }. Klasa, która pisze implements Shape, musi zdefiniować area(), a każda funkcja z typem Shape przyjmie tę klasę.

<?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() nie wie i nie obchodzi go, którą klasę dostaje. Polega tylko na obietnicy, którą składa interfejs, więc nowa klasa Triangle implements Shape zadziała z nią bez zmiany choćby jednej linii.

Programowanie pod interfejs

Zwykły powód napisania interfejsu to pozwolić kodowi zależeć od zdolności, a nie od konkretnej klasy. Tutaj usługa zamówień przyjmuje dowolny Notifier, więc ten sam kod może wysyłać e-maile na produkcji i zbierać wiadomości w teście:

<?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);

Implementowanie kilku interfejsów

Klasa rozszerza najwyżej jednego rodzica, ale może implementować tyle interfejsów, ile potrzebuje. Wymień je po implements, oddzielając przecinkami, i zdefiniuj metody ich wszystkich:

<?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 to jeden z wbudowanych interfejsów PHP: jego implementacja decyduje o tym, co json_encode() zwraca dla obiektu.

Stałe interfejsów

Interfejs może deklarować stałe. Każda implementująca klasa je dziedziczy i można je odczytać przez nazwę interfejsu albo nazwę klasy:

<?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());

W PHP 8.3 interfejsy nie mogą mieć właściwości, tylko metody i stałe. Metody mogą być statyczne: public static function fromArray(array $data): static; w interfejsie zobowiązuje każdą klasę do zdefiniowania tej metody statycznej. Dla stałego zestawu powiązanych wartości enum często pasuje lepiej niż lista stałych w interfejsie.

Interfejs może rozszerzać inne interfejsy

Interfejsy też używają extends i w przeciwieństwie do klas mogą rozszerzać kilka naraz. Klasa implementująca interfejs potomny musi zdefiniować metody całego łańcucha:

<?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);

Interfejsy wbudowane: Countable, IteratorAggregate, Stringable

PHP ma interfejsy, które podłączają obiekty do języka. Countable sprawia, że działa count($obj), IteratorAggregate sprawia, że działa foreach, a Stringable jest implementowany automatycznie przez każdą klasę z metodą __toString():

<?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";

Zapomniana metoda

Jeśli klasa deklaruje, że implementuje interfejs, ale brakuje jej metody, PHP zatrzymuje się z błędem krytycznym, który podaje nazwę brakującej metody:

<?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();

Dodaj metodę total(), a skrypt się wykona. Klasa abstrakcyjna może zostawić metody interfejsu niezdefiniowane i to jest wyjście, które sugeruje komunikat błędu.

Interfejs vs klasa abstrakcyjna

Oba definiują metody, które klasa musi mieć, i oba mogą służyć jako typ. Różnią się tym, co jeszcze mogą zawierać, i tym, ile ich może użyć klasa:

Dobrze się łączą: zdefiniuj interfejs do typowania i zaoferuj abstrakcyjną klasę bazową, która go implementuje ze wspólnym kodem. Klasy, które potrzebują innej bazy, nadal mogą implementować interfejs bezpośrednio.