PHP 인터페이스: implements, 상수, 예제

PHP 인터페이스는 클래스가 제공하겠다고 약속하는 메서드를 코드 없이 선언합니다: interface Shape { public function area(): float; }. implements Shape라고 쓴 클래스는 area()를 정의해야 하고, Shape를 타입 힌트로 쓴 함수는 그 클래스를 받아들입니다.

<?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()는 어떤 클래스를 받는지 알지도 신경 쓰지도 않습니다. 인터페이스가 하는 약속에만 기대므로, 새로운 Triangle implements Shape도 한 줄도 바꾸지 않고 동작합니다.

인터페이스에 맞춰 프로그래밍하기

인터페이스를 쓰는 흔한 이유는 코드가 특정 클래스가 아니라 능력에 의존하게 하려는 것입니다. 여기서 주문 서비스는 어떤 Notifier든 받으므로, 같은 코드가 운영 환경에서는 이메일을 보내고 테스트에서는 메시지를 모을 수 있습니다.

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

여러 인터페이스 구현하기

클래스는 부모를 최대 하나만 상속하지만 인터페이스는 필요한 만큼 구현할 수 있습니다. implements 뒤에 쉼표로 구분해 나열하고 모든 인터페이스의 메서드를 정의하세요.

<?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의 내장 인터페이스 중 하나입니다. 이것을 구현하면 json_encode()가 객체에 대해 무엇을 만들지 제어할 수 있습니다.

인터페이스 상수

인터페이스는 상수를 선언할 수 있습니다. 구현하는 모든 클래스가 그것을 물려받으며, 인터페이스 이름이나 클래스 이름으로 읽을 수 있습니다.

<?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에서 인터페이스는 속성을 가질 수 없고 메서드와 상수만 가질 수 있습니다. 메서드는 정적일 수 있습니다. 인터페이스에 public static function fromArray(array $data): static;을 쓰면 각 클래스가 그 정적 메서드를 정의해야 합니다. 관련된 값의 고정된 집합이라면 인터페이스 상수 목록보다 enum이 더 잘 맞는 경우가 많습니다.

인터페이스는 다른 인터페이스를 확장할 수 있다

인터페이스도 extends를 쓰며, 클래스와 달리 여러 개를 한 번에 확장할 수 있습니다. 자식 인터페이스를 구현하는 클래스는 체인 전체의 메서드를 정의해야 합니다.

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

내장 인터페이스: Countable, IteratorAggregate, Stringable

PHP에는 객체를 언어에 연결하는 인터페이스가 들어 있습니다. Countable은 count($obj)를, IteratorAggregate는 foreach를 동작하게 하고, Stringable은 __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";

메서드 빠뜨리기

클래스가 인터페이스를 구현한다고 하면서 메서드를 빠뜨리면 PHP는 빠진 메서드를 알려 주는 치명적 에러와 함께 멈춥니다.

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

total() 메서드를 추가하면 스크립트가 실행됩니다. 추상 클래스는 인터페이스 메서드를 정의하지 않은 채로 둘 수 있으며, 에러 메시지가 제안하는 우회 방법이 이것입니다.

인터페이스와 추상 클래스

둘 다 클래스가 가져야 할 메서드를 정의하고, 둘 다 타입 힌트로 쓸 수 있습니다. 차이는 그 밖에 무엇을 담을 수 있는지와 클래스가 몇 개를 쓸 수 있는지입니다.

둘은 함께 잘 쓰입니다. 타입 힌트용으로 인터페이스를 정의하고, 공통 코드로 그것을 구현하는 추상 기반 클래스를 제공하세요. 다른 기반 클래스가 필요한 클래스는 여전히 인터페이스를 직접 구현할 수 있습니다.