Абстрактный класс PHP: абстрактные методы и применение

Абстрактный класс PHP объявляется как abstract class Name, и создать его через new нельзя. Это база для других классов: у него могут быть свойства, конструктор и готовые методы, а также abstract-методы без тела, которые обязан реализовать каждый дочерний класс.

<?php
abstract class Shape
{
    public function __construct(protected string $label) {}

    abstract public function area(): float;

    public function describe(): string
    {
        return sprintf('%s: %.2f', $this->label, $this->area());
    }
}

class Rectangle extends Shape
{
    public function __construct(private float $w, private float $h)
    {
        parent::__construct('Rectangle');
    }

    public function area(): float
    {
        return $this->w * $this->h;
    }
}

class Circle extends Shape
{
    public function __construct(private float $r)
    {
        parent::__construct('Circle');
    }

    public function area(): float
    {
        return M_PI * $this->r ** 2;
    }
}

foreach ([new Rectangle(3, 4), new Circle(1.5)] as $shape) {
    echo $shape->describe(), "\n";
}

describe() написан один раз в Shape и вызывает area(), который предоставляет каждый дочерний класс. Абстрактный класс гарантирует, что такой метод существует, поэтому describe() может на него полагаться.

Абстрактный класс нельзя создать через new

Абстрактный класс намеренно неполон: у Shape::area() нет тела, поэтому простому объекту Shape нечего было бы выполнять. PHP отказывается его создавать и выбрасывает Error:

<?php
abstract class Shape
{
    abstract public function area(): float;
}

try {
    $s = new Shape();
} catch (Error $e) {
    echo get_class($e), ': ', $e->getMessage(), "\n";
}

$r = new ReflectionClass('Shape');
var_dump($r->isAbstract());

Абстрактные методы: правила

У абстрактного метода есть сигнатура и точка с запятой вместо тела. Каждый дочерний класс должен реализовать его с совместимой сигнатурой и той же или более широкой видимостью: метод abstract protected может стать в дочернем классе protected или public, но никогда private. Класс, в котором есть хотя бы один абстрактный метод, сам должен быть объявлен абстрактным.

<?php
abstract class Notification
{
    public function __construct(protected string $recipient) {}

    abstract protected function channel(): string;

    abstract protected function format(string $text): string;

    public function send(string $text): string
    {
        return "[{$this->channel()}] to {$this->recipient}: " . $this->format($text);
    }
}

class SmsNotification extends Notification
{
    protected function channel(): string
    {
        return 'SMS';
    }

    protected function format(string $text): string
    {
        return rtrim(mb_substr($text, 0, 20)) . (mb_strlen($text) > 20 ? '...' : '');
    }
}

class EmailNotification extends Notification
{
    public function channel(): string   // protected widened to public: allowed
    {
        return 'Email';
    }

    protected function format(string $text): string
    {
        return "Hello,\n\n$text\n\nRegards";
    }
}

echo (new SmsNotification('+3912345'))->send('Your parcel arrives tomorrow between 9 and 12'), "\n\n";
echo (new EmailNotification('ada@example.com'))->send('Your parcel arrives tomorrow.'), "\n";

Дочерний класс, который пропустил абстрактный метод, останавливает скрипт до того, как выполнится хоть что-то, если только он сам не объявлен абстрактным и не оставляет метод своим потомкам:

PHP Fatal error:  Class Square contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (Shape::area) in /home/index.php on line 3

Шаблонный метод

Самая частая причина написать абстрактный класс: фиксированная последовательность шагов, где несколько шагов отличаются. Базовый класс владеет последовательностью в методе final, а дочерние заполняют шаги. Здесь один и тот же отчёт выводится обычным текстом и HTML-таблицей:

<?php
abstract class Report
{
    public function __construct(protected array $rows) {}

    final public function render(): string
    {
        $out = $this->open();
        foreach ($this->rows as $row) {
            $out .= $this->row($row);
        }
        return $out . $this->close();
    }

    abstract protected function row(array $row): string;

    protected function open(): string { return ''; }
    protected function close(): string { return ''; }
}

class TextReport extends Report
{
    protected function row(array $row): string
    {
        return str_pad($row[0], 10) . $row[1] . "\n";
    }
}

class HtmlReport extends Report
{
    protected function open(): string { return "<table border=\"1\">\n"; }
    protected function close(): string { return "</table>\n"; }

    protected function row(array $row): string
    {
        return '<tr><td>' . htmlspecialchars($row[0]) . '</td><td>' . $row[1] . "</td></tr>\n";
    }
}

$rows = [['Apples', 12], ['Pears', 7], ['Plums', 30]];
echo (new HtmlReport($rows))->render();
echo '<pre>' . (new TextReport($rows))->render() . '</pre>';

Запустите, и вкладка Page покажет HTML-таблицу над текстовой версией. У open() и close() есть тела по умолчанию, поэтому их переопределяет только HtmlReport; row() абстрактный, потому что разумного варианта по умолчанию нет. final у render() не даёт дочернему классу поменять порядок шагов.

Абстрактный класс может реализовать интерфейс

Абстрактный класс может объявить implements и оставить часть методов интерфейса своим потомкам. Это стандартный способ сочетать интерфейс (тип) с базовым классом (общий код):

<?php
interface Cache
{
    public function get(string $key): mixed;
    public function set(string $key, mixed $value): void;
    public function has(string $key): bool;
}

abstract class BaseCache implements Cache
{
    // has() is written once, in terms of get()
    public function has(string $key): bool
    {
        return $this->get($key) !== null;
    }
}

class ArrayCache extends BaseCache
{
    private array $items = [];

    public function get(string $key): mixed
    {
        return $this->items[$key] ?? null;
    }

    public function set(string $key, mixed $value): void
    {
        $this->items[$key] = $value;
    }
}

$cache = new ArrayCache();
$cache->set('user:1', 'Ada');
var_dump($cache->has('user:1'), $cache->has('user:2'));
var_dump($cache instanceof Cache);

Код использует подсказку типа по интерфейсу Cache, поэтому класс, который не может наследовать BaseCache (потому что уже наследует что-то другое), всё равно может реализовать Cache напрямую.

Когда использовать абстрактный класс, а когда нет

Берите абстрактный класс, когда у классов одного семейства есть настоящий общий код: свойства, конструктор, методы, одинаковые для всех. Если в базе были бы одни абстрактные методы, это замаскированный интерфейс, и интерфейс здесь лучше, потому что класс может реализовать много интерфейсов, а наследовать только один класс. Если нужно лишь поделиться несколькими вспомогательными методами между несвязанными классами, используйте трейт, а не загоняйте их под одного родителя.

Быстрая проверка перед тем, как писать abstract class: будет ли каждый дочерний класс действительно разновидностью базы (Circle это Shape)? Если честный ответ "он умеет это", а не "он один из них", пишите интерфейс.