PHP Interface: implements, Constants and Examples

A PHP interface declares methods that a class promises to provide, without any code: interface Shape { public function area(): float; }. A class that writes implements Shape must define area(), and any function that type-hints Shape will accept that class.

<?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() does not know or care which class it receives. It only relies on the promise the interface makes, so a new Triangle implements Shape works with it without changing a line.

Program to an interface

The usual reason to write an interface is to let code depend on a capability rather than a specific class. Here an order service accepts any Notifier, so the same code can send email in production and collect messages in a 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);

Implement multiple interfaces

A class extends at most one parent, but it can implement as many interfaces as it needs. List them after implements, separated by commas, and define the methods of all of them:

<?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 is one of PHP's built-in interfaces: implementing it controls what json_encode() produces for the object.

Interface constants

An interface can declare constants. Every implementing class inherits them, and you can read them through the interface name or the class name:

<?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 cannot have properties in PHP 8.3, only methods and constants. The methods may be static: public static function fromArray(array $data): static; in the interface obliges each class to define that static method. For a fixed set of related values, an enum is often a better fit than a list of interface constants.

An interface can extend other interfaces

Interfaces use extends too, and unlike classes they can extend several at once. A class implementing the child interface must define the methods of the whole chain:

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

Built-in interfaces: Countable, IteratorAggregate, Stringable

PHP ships interfaces that hook objects into the language. Countable makes count($obj) work, IteratorAggregate makes foreach work, and Stringable is implemented automatically by any class with a __toString() method:

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

Forgetting a method

If a class claims to implement an interface but misses a method, PHP stops with a fatal error that names the missing method:

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

Add a total() method and the script runs. An abstract class may leave interface methods undefined, which is the escape hatch the error message suggests.

Interface vs abstract class

Both define methods a class must have, and both can be used as a type hint. The difference is what else they may contain and how many a class can use:

They combine well: define the interface for the type hint, and offer an abstract base class that implements it with the common code. Classes that need a different base can still implement the interface directly.