PHP Interface (Arayüz): implements, Sabitler ve Örnekler

Bir PHP arayüzü, bir sınıfın sağlamayı vaat ettiği metotları hiç kod olmadan tanımlar: interface Shape { public function area(): float; }. implements Shape yazan bir sınıf area() metodunu tanımlamak zorundadır ve Shape tür ipucu kullanan her fonksiyon o sınıfı kabul eder.

<?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() hangi sınıfı aldığını bilmez ve umursamaz. Yalnızca arayüzün verdiği söze güvenir, bu yüzden yeni bir Triangle implements Shape tek satır değiştirmeden onunla çalışır.

Bir arayüze göre programlama

Arayüz yazmanın olağan nedeni, kodun belirli bir sınıf yerine bir yeteneğe bağlı olmasını sağlamaktır. Burada bir sipariş servisi herhangi bir Notifier kabul eder, böylece aynı kod üretimde e-posta gönderebilir ve bir testte mesajları toplayabilir:

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

Birden çok arayüz uygulama

Bir sınıf en fazla bir üst sınıfı genişletir, ama ihtiyaç duyduğu kadar arayüz uygulayabilir. Onları implements sonrasında virgülle ayırarak listeleyin ve hepsinin metotlarını tanımlayın:

<?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 PHP'nin yerleşik arayüzlerinden biridir: onu uygulamak json_encode() fonksiyonunun nesne için ne üreteceğini belirler.

Arayüz sabitleri

Bir arayüz sabitler tanımlayabilir. Onu uygulayan her sınıf bunları kalıtır ve onları arayüz adı veya sınıf adı üzerinden okuyabilirsiniz:

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

PHP 8.3'te arayüzlerin özellikleri olamaz, yalnızca metotları ve sabitleri olabilir. Metotlar statik olabilir: arayüzdeki public static function fromArray(array $data): static; her sınıfı o statik metodu tanımlamaya zorlar. Sabit bir ilişkili değerler kümesi için bir enum çoğu zaman bir arayüz sabitleri listesinden daha uygundur.

Bir arayüz başka arayüzleri genişletebilir

Arayüzler de extends kullanır ve sınıfların aksine aynı anda birkaçını genişletebilir. Alt arayüzü uygulayan bir sınıf bütün zincirin metotlarını tanımlamalıdır:

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

Yerleşik arayüzler: Countable, IteratorAggregate, Stringable

PHP nesneleri dile bağlayan arayüzlerle gelir. Countable count($obj) ifadesini, IteratorAggregate foreach döngüsünü çalıştırır ve Stringable __toString() metodu olan her sınıf tarafından otomatik olarak uygulanır:

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

Bir metodu unutmak

Bir sınıf bir arayüzü uyguladığını söyleyip bir metodu atlarsa PHP eksik metodu adıyla belirten ölümcül bir hatayla durur:

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

Bir total() metodu ekleyin, betik çalışır. Bir soyut sınıf arayüz metotlarını tanımsız bırakabilir; hata mesajının önerdiği çıkış yolu budur.

Arayüz ile soyut sınıf

İkisi de bir sınıfın sahip olması gereken metotları tanımlar ve ikisi de tür ipucu olarak kullanılabilir. Fark, başka neler içerebildikleri ve bir sınıfın kaç tanesini kullanabildiğidir:

Birlikte iyi çalışırlar: tür ipucu için arayüzü tanımlayın ve onu ortak kodla uygulayan soyut bir temel sınıf sunun. Farklı bir temel sınıfa ihtiyaç duyan sınıflar yine de arayüzü doğrudan uygulayabilir.