Interface PHP : implements, constantes et exemples

Une interface PHP déclare des méthodes qu'une classe promet de fournir, sans aucun code : interface Shape { public function area(): float; }. Une classe qui écrit implements Shape doit définir area(), et toute fonction qui type un paramètre avec Shape acceptera cette 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() ne sait pas, et ne se soucie pas de savoir, quelle classe elle reçoit. Elle ne compte que sur la promesse de l'interface, donc un nouveau Triangle implements Shape fonctionne avec elle sans changer une ligne.

Programmer pour une interface

La raison habituelle d'écrire une interface est de faire dépendre le code d'une capacité plutôt que d'une classe précise. Ici, un service de commandes accepte n'importe quel Notifier, donc le même code peut envoyer des emails en production et collecter les messages dans 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);

Implémenter plusieurs interfaces

Une classe étend au plus un parent, mais elle peut implémenter autant d'interfaces que nécessaire. Listez-les après implements, séparées par des virgules, et définissez les méthodes de toutes :

<?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 est l'une des interfaces natives de PHP : l'implémenter contrôle ce que produit json_encode() pour l'objet.

Constantes d'interface

Une interface peut déclarer des constantes. Chaque classe qui l'implémente en hérite, et vous pouvez les lire via le nom de l'interface ou celui de la 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());

Les interfaces ne peuvent pas avoir de propriétés en PHP 8.3, seulement des méthodes et des constantes. Les méthodes peuvent être statiques : public static function fromArray(array $data): static; dans l'interface oblige chaque classe à définir cette méthode statique. Pour un ensemble fixe de valeurs liées, une enum convient souvent mieux qu'une liste de constantes d'interface.

Une interface peut en étendre d'autres

Les interfaces utilisent aussi extends, et contrairement aux classes elles peuvent en étendre plusieurs à la fois. Une classe qui implémente l'interface enfant doit définir les méthodes de toute la chaîne :

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

Interfaces natives : Countable, IteratorAggregate, Stringable

PHP fournit des interfaces qui relient les objets au langage. Countable fait fonctionner count($obj), IteratorAggregate fait fonctionner foreach, et Stringable est implémentée automatiquement par toute classe ayant une méthode __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";

Oublier une méthode

Si une classe affirme implémenter une interface mais oublie une méthode, PHP s'arrête avec une erreur fatale qui nomme la méthode manquante :

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

Ajoutez une méthode total() et le script s'exécute. Une classe abstraite peut laisser des méthodes d'interface non définies, c'est l'échappatoire que suggère le message d'erreur.

Interface ou classe abstraite

Les deux définissent des méthodes qu'une classe doit avoir, et les deux peuvent servir de type. La différence tient à ce qu'elles peuvent contenir d'autre et au nombre qu'une classe peut utiliser :

Elles se combinent bien : définissez l'interface pour le typage, et proposez une classe de base abstraite qui l'implémente avec le code commun. Les classes qui ont besoin d'une autre base peuvent toujours implémenter directement l'interface.