Klasa abstrakcyjna w PHP: metody abstrakcyjne i zastosowania

Klasę abstrakcyjną w PHP deklaruje się przez abstract class Name i nie można jej utworzyć przez new. Jest bazą dla innych klas: może mieć właściwości, konstruktor i gotowe metody oraz metody abstract bez treści, które musi zaimplementować każda klasa potomna.

<?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() jest napisane raz w Shape i wywołuje area(), które dostarcza każdy potomek. Klasa abstrakcyjna gwarantuje, że ta metoda istnieje, więc describe() może na niej polegać.

Klasy abstrakcyjnej nie utworzysz przez new

Klasa abstrakcyjna jest celowo niekompletna: Shape::area() nie ma treści, więc zwykły obiekt Shape nie miałby czego wykonać. PHP odmawia jego utworzenia i rzuca 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());

Metody abstrakcyjne: zasady

Metoda abstrakcyjna ma sygnaturę i średnik zamiast treści. Każdy potomek musi ją zaimplementować ze zgodną sygnaturą i taką samą lub szerszą widocznością: metoda abstract protected może stać się w potomku protected albo public, nigdy private. Klasa z choćby jedną metodą abstrakcyjną sama musi być zadeklarowana jako abstrakcyjna.

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

Potomek, który pominie metodę abstrakcyjną, zatrzymuje skrypt, zanim cokolwiek się wykona, chyba że sam też jest zadeklarowany jako abstrakcyjny i zostawia tę metodę swoim potomkom:

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

Wzorzec metody szablonowej

Najczęstszy powód napisania klasy abstrakcyjnej: stała sekwencja kroków, z których kilka się różni. Klasa bazowa posiada sekwencję w metodzie final, a potomkowie uzupełniają kroki. Tutaj ten sam raport działa jako zwykły tekst i jako tabela 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>';

Uruchom, a zakładka Page pokaże tabelę HTML nad wersją tekstową. open() i close() mają domyślną treść, więc nadpisuje je tylko HtmlReport; row() jest abstrakcyjna, bo nie ma sensownej wartości domyślnej. Oznaczenie render() jako final nie pozwala potomkowi zmienić kolejności kroków.

Klasa abstrakcyjna może implementować interfejs

Klasa abstrakcyjna może zadeklarować implements i zostawić część metod interfejsu swoim potomkom. To standardowy sposób łączenia interfejsu (typu) z klasą bazową (wspólnym kodem):

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

Kod używa interfejsu Cache jako typu, więc klasa, która nie może rozszerzać BaseCache (bo już rozszerza coś innego), nadal może implementować Cache bezpośrednio.

Kiedy używać klasy abstrakcyjnej, a kiedy nie

Sięgnij po klasę abstrakcyjną, gdy klasy w rodzinie współdzielą prawdziwy kod: właściwości, konstruktor, metody takie same dla wszystkich. Jeśli baza zawierałaby wyłącznie metody abstrakcyjne, to jest to przebrany interfejs, a interfejs jest lepszym wyborem, bo klasa może implementować wiele interfejsów, ale rozszerzać tylko jedną klasę. Jeśli chcesz tylko współdzielić kilka metod pomocniczych między niepowiązanymi klasami, użyj traitu, zamiast wciskać je pod jednego rodzica.

Szybki test przed napisaniem abstract class: czy każdy potomek naprawdę jest rodzajem bazy (Circle jest Shape)? Jeśli uczciwa odpowiedź brzmi „potrafi to robić”, a nie „jest jednym z nich”, napisz interfejs.