Interfaces en PHP: implements, constantes y ejemplos

Una interfaz de PHP declara los métodos que una clase promete ofrecer, sin ningún código: interface Shape { public function area(): float; }. Una clase que escribe implements Shape debe definir area(), y cualquier función con la declaración de tipo Shape aceptará esa clase.

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

A describe() no le importa qué clase recibe. Solo depende de la promesa que hace la interfaz, así que un nuevo Triangle implements Shape funciona con ella sin cambiar una línea.

Programar contra una interfaz

El motivo habitual para escribir una interfaz es que el código dependa de una capacidad y no de una clase concreta. Aquí un servicio de pedidos acepta cualquier Notifier, así que el mismo código puede enviar emails en producción y reunir los mensajes en 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);

Implementar varias interfaces

Una clase extiende como mucho un padre, pero puede implementar tantas interfaces como necesite. Enuméralas después de implements, separadas por comas, y define los métodos de todas ellas:

<?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 es una de las interfaces nativas de PHP: implementarla controla lo que produce json_encode() para el objeto.

Constantes de interfaz

Una interfaz puede declarar constantes. Todas las clases que la implementan las heredan, y puedes leerlas a través del nombre de la interfaz o del de la clase:

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

En PHP 8.3 las interfaces no pueden tener propiedades, solo métodos y constantes. Los métodos pueden ser estáticos: public static function fromArray(array $data): static; en la interfaz obliga a cada clase a definir ese método estático. Para un conjunto fijo de valores relacionados, un enum suele encajar mejor que una lista de constantes de interfaz.

Una interfaz puede extender otras interfaces

Las interfaces también usan extends y, a diferencia de las clases, pueden extender varias a la vez. Una clase que implementa la interfaz hija debe definir los métodos de toda la cadena:

<?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 nativas: Countable, IteratorAggregate, Stringable

PHP trae interfaces que conectan los objetos con el lenguaje. Countable hace que funcione count($obj), IteratorAggregate hace que funcione foreach, y Stringable la implementa automáticamente cualquier clase con un método __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";

Olvidar un método

Si una clase dice implementar una interfaz pero le falta un método, PHP se detiene con un error fatal que nombra el método que falta:

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

Añade un método total() y el script funciona. Una clase abstracta puede dejar sin definir métodos de la interfaz, que es la salida que sugiere el mensaje de error.

Interfaz vs clase abstracta

Las dos definen métodos que una clase debe tener, y las dos se pueden usar como declaración de tipo. La diferencia está en qué más pueden contener y cuántas puede usar una clase:

Se combinan bien: define la interfaz para la declaración de tipo y ofrece una clase base abstracta que la implemente con el código común. Las clases que necesiten otra base pueden seguir implementando la interfaz directamente.