Interface trong PHP: implements, hằng số và ví dụ

Interface trong PHP khai báo các phương thức mà một lớp cam kết cung cấp, nhưng không chứa code nào: interface Shape { public function area(): float; }. Lớp nào viết implements Shape thì phải định nghĩa area(), và mọi hàm có type hint Shape đều chấp nhận lớp đó.

<?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() không biết và cũng không quan tâm nó nhận lớp nào. Hàm chỉ dựa vào lời cam kết của interface, nên một Triangle implements Shape mới vẫn chạy được với nó mà không phải sửa dòng code nào.

Lập trình theo interface

Lý do thường gặp nhất để viết interface là cho phép code phụ thuộc vào một khả năng thay vì một lớp cụ thể. Ở đây, một service đơn hàng nhận bất kỳ Notifier nào, nên cùng một đoạn code có thể gửi email khi chạy thật và gom tin nhắn lại khi chạy 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 nhiều interface

Một lớp chỉ extends tối đa một lớp cha, nhưng có thể implement bao nhiêu interface tùy ý. Liệt kê chúng sau implements, cách nhau bằng dấu phẩy, rồi định nghĩa phương thức của tất cả:

<?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 là một trong các interface có sẵn của PHP: implement nó cho phép bạn quyết định json_encode() tạo ra gì cho đối tượng.

Hằng số trong interface

Interface có thể khai báo hằng số. Mọi lớp implement đều kế thừa chúng, và bạn có thể đọc chúng qua tên interface hoặc tên lớp:

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

Trong PHP 8.3, interface không có thuộc tính, chỉ có phương thức và hằng số. Phương thức có thể là static: public static function fromArray(array $data): static; trong interface buộc mỗi lớp phải định nghĩa phương thức static đó. Với một tập giá trị cố định có liên quan với nhau, enum thường phù hợp hơn một danh sách hằng số trong interface.

Interface có thể kế thừa interface khác

Interface cũng dùng extends, và khác với lớp, chúng có thể kế thừa nhiều interface cùng lúc. Lớp implement interface con phải định nghĩa phương thức của cả chuỗi:

<?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 có sẵn: Countable, IteratorAggregate, Stringable

PHP có sẵn các interface giúp đối tượng gắn vào chính ngôn ngữ. Countable giúp count($obj) hoạt động, IteratorAggregate giúp foreach hoạt động, còn Stringable được tự động implement bởi mọi lớp có phương thức __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";

Quên một phương thức

Nếu một lớp tuyên bố implement một interface nhưng thiếu một phương thức, PHP dừng lại với lỗi nghiêm trọng nêu rõ tên phương thức bị thiếu:

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

Thêm phương thức total() là script chạy được. Một lớp trừu tượng được phép để trống các phương thức của interface, đó chính là lối thoát mà thông báo lỗi gợi ý.

Interface và lớp trừu tượng

Cả hai đều định nghĩa các phương thức mà một lớp phải có, và cả hai đều dùng được làm type hint. Khác biệt nằm ở những gì khác chúng có thể chứa và một lớp dùng được bao nhiêu cái:

Hai thứ này kết hợp rất tốt: định nghĩa interface để làm type hint, và cung cấp một lớp cơ sở trừu tượng implement interface đó với phần code chung. Những lớp cần một lớp cơ sở khác vẫn có thể implement interface trực tiếp.