Interfacce in PHP: implements, costanti ed esempi

Un'interfaccia PHP dichiara i metodi che una classe promette di fornire, senza alcun codice: interface Shape { public function area(): float; }. Una classe che scrive implements Shape deve definire area(), e qualsiasi funzione che usa Shape come type hint accetterà quella classe.

<?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() non sa né si preoccupa di quale classe riceve. Si basa solo sulla promessa fatta dall'interfaccia, quindi un nuovo Triangle implements Shape funziona con essa senza cambiare una riga.

Programmare verso un'interfaccia

Il motivo abituale per scrivere un'interfaccia è far dipendere il codice da una capacità invece che da una classe specifica. Qui un servizio ordini accetta qualsiasi Notifier, quindi lo stesso codice può inviare email in produzione e raccogliere messaggi in un test:

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

Implementare più interfacce

Una classe estende al massimo un padre, ma può implementare tutte le interfacce che le servono. Elencale dopo implements, separate da virgole, e definisci i metodi di tutte:

<?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 è una delle interfacce predefinite di PHP: implementarla controlla cosa produce json_encode() per l'oggetto.

Costanti delle interfacce

Un'interfaccia può dichiarare costanti. Ogni classe che la implementa le eredita, e puoi leggerle tramite il nome dell'interfaccia o della classe:

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

In PHP 8.3 le interfacce non possono avere proprietà, solo metodi e costanti. I metodi possono essere statici: public static function fromArray(array $data): static; nell'interfaccia obbliga ogni classe a definire quel metodo statico. Per un insieme fisso di valori correlati, un enum è spesso più adatto di un elenco di costanti di interfaccia.

Un'interfaccia può estendere altre interfacce

Anche le interfacce usano extends, e a differenza delle classi possono estenderne più di una insieme. Una classe che implementa l'interfaccia figlia deve definire i metodi dell'intera catena:

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

Interfacce predefinite: Countable, IteratorAggregate, Stringable

PHP include interfacce che agganciano gli oggetti al linguaggio. Countable fa funzionare count($obj), IteratorAggregate fa funzionare foreach, e Stringable viene implementata automaticamente da qualsiasi classe con un metodo __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";

Dimenticare un metodo

Se una classe dichiara di implementare un'interfaccia ma le manca un metodo, PHP si ferma con un errore fatale che indica il metodo mancante:

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

Aggiungi un metodo total() e lo script viene eseguito. Una classe astratta può lasciare non definiti i metodi dell'interfaccia, ed è la via d'uscita suggerita dal messaggio di errore.

Interfaccia vs classe astratta

Entrambe definiscono metodi che una classe deve avere, ed entrambe si possono usare come type hint. La differenza è cos'altro possono contenere e quante una classe ne può usare:

Si combinano bene: definisci l'interfaccia per il type hint, e offri una classe base astratta che la implementa con il codice comune. Le classi che hanno bisogno di una base diversa possono comunque implementare direttamente l'interfaccia.