PHP abstrakte Klasse: abstrakte Methoden und Einsatz

Eine abstrakte PHP-Klasse wird mit abstract class Name deklariert und lässt sich nicht mit new erzeugen. Sie ist eine Basis für andere Klassen: Sie kann Eigenschaften, einen Konstruktor und fertige Methoden haben, dazu abstract-Methoden ohne Rumpf, die jede Kindklasse implementieren muss.

<?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() wird einmal in Shape geschrieben und ruft area() auf, das jedes Kind liefert. Die abstrakte Klasse garantiert, dass die Methode existiert, also kann sich describe() darauf verlassen.

Eine abstrakte Klasse lässt sich nicht mit new erzeugen

Eine abstrakte Klasse ist absichtlich unvollständig: Shape::area() hat keinen Rumpf, also hätte ein einfaches Shape-Objekt nichts auszuführen. PHP weigert sich, eines zu erzeugen, und wirft einen 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());

Abstrakte Methoden: die Regeln

Eine abstrakte Methode hat eine Signatur und ein Semikolon statt eines Rumpfs. Jedes Kind muss sie mit kompatibler Signatur und derselben oder einer weiteren Sichtbarkeit implementieren: Eine abstract protected-Methode darf im Kind protected oder public werden, nie private. Eine Klasse mit auch nur einer abstrakten Methode muss selbst als abstract deklariert sein.

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

Ein Kind, das eine abstrakte Methode auslässt, stoppt das Skript, bevor irgendetwas davon läuft, außer das Kind ist ebenfalls als abstract deklariert und überlässt die Methode seinen eigenen Kindern:

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

Das Template-Method-Muster

Der häufigste Grund für eine abstrakte Klasse: eine feste Folge von Schritten, in der sich einige Schritte unterscheiden. Die Basisklasse besitzt die Folge in einer final-Methode, und die Kinder füllen die Schritte aus. Hier läuft derselbe Bericht als reiner Text und als HTML-Tabelle:

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

Führe es aus, und der Tab Page zeigt die HTML-Tabelle über der Textversion. open() und close() haben Standardrümpfe, also überschreibt nur HtmlReport sie; row() ist abstrakt, weil es keinen sinnvollen Standard gibt. render() als final zu markieren verhindert, dass ein Kind die Reihenfolge der Schritte ändert.

Eine abstrakte Klasse kann ein Interface implementieren

Eine abstrakte Klasse darf implements deklarieren und einige Methoden des Interfaces ihren Kindern überlassen. Das ist der Standardweg, ein Interface (den Typ) mit einer Basisklasse (dem gemeinsamen Code) zu kombinieren:

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

Der Code verwendet das Interface Cache als Typangabe, also kann eine Klasse, die BaseCache nicht erweitern kann (weil sie schon etwas anderes erweitert), Cache trotzdem direkt implementieren.

Wann eine abstrakte Klasse passt und wann nicht

Greif zu einer abstrakten Klasse, wenn die Klassen einer Familie echten Code teilen: Eigenschaften, einen Konstruktor, Methoden, die für alle gleich sind. Wenn die Basis nur abstrakte Methoden enthalten würde, ist sie ein verkleidetes Interface, und ein Interface ist die bessere Wahl, weil eine Klasse viele Interfaces implementieren, aber nur eine Klasse erweitern kann. Wenn du nur ein paar Hilfsmethoden zwischen nicht verwandten Klassen teilen willst, verwendest du einen Trait, statt sie unter eine Elternklasse zu zwingen.

Ein schneller Test, bevor du abstract class schreibst: Wäre jedes Kind wirklich eine Art der Basis (Circle ist eine Shape)? Lautet die ehrliche Antwort „es kann das“ statt „es ist eines davon“, schreib ein Interface.