Interface em PHP: implements, constantes e exemplos

Uma interface PHP declara métodos que uma classe promete fornecer, sem nenhum código: interface Shape { public function area(): float; }. Uma classe que escreve implements Shape precisa definir area(), e qualquer função com type hint Shape vai aceitar essa 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() não sabe nem se importa com qual classe recebe. Ela só confia na promessa que a interface faz, então um novo Triangle implements Shape funciona com ela sem mudar uma linha.

Programar para uma interface

O motivo comum para escrever uma interface é deixar o código depender de uma capacidade em vez de uma classe específica. Aqui um serviço de pedidos aceita qualquer Notifier, então o mesmo código pode enviar e-mail em produção e guardar mensagens num teste:

<?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 várias interfaces

Uma classe estende no máximo uma classe pai, mas pode implementar quantas interfaces precisar. Liste-as depois de implements, separadas por vírgulas, e defina os métodos de todas:

<?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 é uma das interfaces nativas do PHP: implementá-la controla o que o json_encode() produz para o objeto.

Constantes de interface

Uma interface pode declarar constantes. Todas as classes que a implementam as herdam, e você pode lê-las pelo nome da interface ou pelo nome da 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());

Interfaces não podem ter propriedades no PHP 8.3, só métodos e constantes. Os métodos podem ser estáticos: public static function fromArray(array $data): static; na interface obriga cada classe a definir esse método estático. Para um conjunto fixo de valores relacionados, um enum muitas vezes serve melhor que uma lista de constantes de interface.

Uma interface pode estender outras interfaces

Interfaces também usam extends e, ao contrário das classes, podem estender várias ao mesmo tempo. Uma classe que implementa a interface filha precisa definir os métodos da cadeia inteira:

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

O PHP traz interfaces que ligam objetos à linguagem. Countable faz count($obj) funcionar, IteratorAggregate faz o foreach funcionar, e Stringable é implementada automaticamente por qualquer classe com um 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";

Esquecer um método

Se uma classe diz implementar uma interface mas deixa faltar um método, o PHP para com um erro fatal que nomeia o método ausente:

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

Adicione um método total() e o script roda. Uma classe abstrata pode deixar métodos da interface sem definição, que é a saída que a mensagem de erro sugere.

Interface ou classe abstrata

As duas definem métodos que uma classe precisa ter, e as duas podem ser usadas como type hint. A diferença está no que mais elas podem conter e em quantas uma classe pode usar:

Elas combinam bem: defina a interface para o type hint e ofereça uma classe base abstrata que a implementa com o código comum. Classes que precisam de outra base ainda podem implementar a interface diretamente.