Interface PHP: implements, Konstanta, dan Contoh

Interface PHP mendeklarasikan method yang dijanjikan akan disediakan sebuah class, tanpa kode apa pun: interface Shape { public function area(): float; }. Class yang menulis implements Shape wajib mendefinisikan area(), dan fungsi apa pun yang memakai type hint Shape akan menerima class itu.

<?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() tidak tahu dan tidak peduli class mana yang diterimanya. Fungsi itu hanya mengandalkan janji yang dibuat interface, jadi Triangle implements Shape yang baru langsung bekerja dengannya tanpa mengubah satu baris pun.

Memprogram berdasarkan interface

Alasan umum menulis interface adalah agar kode bergantung pada sebuah kemampuan, bukan pada class tertentu. Di sini sebuah service pesanan menerima Notifier apa pun, jadi kode yang sama bisa mengirim email di production dan mengumpulkan pesan di pengujian:

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

Mengimplementasikan beberapa interface

Sebuah class meng-extend paling banyak satu parent, tetapi bisa mengimplementasikan interface sebanyak yang dibutuhkan. Tulis semuanya setelah implements, dipisahkan koma, lalu definisikan method dari semuanya:

<?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 adalah salah satu interface bawaan PHP: mengimplementasikannya mengatur apa yang dihasilkan json_encode() untuk object tersebut.

Konstanta interface

Interface bisa mendeklarasikan konstanta. Setiap class yang mengimplementasikannya mewarisi konstanta itu, dan kamu bisa membacanya lewat nama interface atau nama class:

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

Interface tidak bisa punya property di PHP 8.3, hanya method dan konstanta. Method-nya boleh static: public static function fromArray(array $data): static; di interface mewajibkan setiap class mendefinisikan method static tersebut. Untuk sekumpulan nilai terkait yang tetap, enum sering lebih cocok daripada daftar konstanta interface.

Interface bisa meng-extend interface lain

Interface juga memakai extends, dan tidak seperti class, interface bisa meng-extend beberapa sekaligus. Class yang mengimplementasikan interface turunan itu wajib mendefinisikan method dari seluruh rantainya:

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

Interface bawaan: Countable, IteratorAggregate, Stringable

PHP menyediakan interface yang menghubungkan object dengan fitur bahasa. Countable membuat count($obj) berfungsi, IteratorAggregate membuat foreach berfungsi, dan Stringable diimplementasikan secara otomatis oleh class apa pun yang punya method __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";

Lupa sebuah method

Jika sebuah class mengaku mengimplementasikan interface tetapi melewatkan sebuah method, PHP berhenti dengan fatal error yang menyebut nama method yang hilang:

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

Tambahkan method total() dan script-nya berjalan. Abstract class boleh membiarkan method interface tidak didefinisikan, dan itulah jalan keluar yang disarankan oleh pesan error-nya.

Interface vs abstract class

Keduanya mendefinisikan method yang wajib dimiliki sebuah class, dan keduanya bisa dipakai sebagai type hint. Perbedaannya ada pada apa lagi yang boleh dimuat dan berapa banyak yang bisa dipakai sebuah class:

Keduanya cocok dipadukan: definisikan interface untuk type hint, lalu sediakan abstract base class yang mengimplementasikannya dengan kode yang umum. Class yang membutuhkan base lain tetap bisa mengimplementasikan interface itu secara langsung.