Classi astratte in PHP: metodi astratti e quando usarle

Una classe astratta PHP si dichiara con abstract class Name e non può essere creata con new. È una base per altre classi: può avere proprietà, un costruttore e metodi completi, più metodi abstract senza corpo, che ogni classe figlia deve implementare.

<?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() è scritto una volta in Shape e chiama area(), che ogni figlia fornisce. La classe astratta garantisce che il metodo esista, quindi describe() può contarci.

Non puoi creare una classe astratta con new

Una classe astratta è incompleta di proposito: Shape::area() non ha corpo, quindi un semplice oggetto Shape non avrebbe nulla da eseguire. PHP si rifiuta di crearne uno e lancia un 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());

Metodi astratti: le regole

Un metodo astratto ha una firma e un punto e virgola al posto del corpo. Ogni figlia deve implementarlo con una firma compatibile e una visibilità uguale o più ampia: un metodo abstract protected può diventare protected o public nella figlia, mai private. Una classe con anche un solo metodo astratto deve essere a sua volta dichiarata astratta.

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

Una figlia che salta un metodo astratto ferma lo script prima che ne venga eseguita qualsiasi parte, a meno che la figlia non sia anch'essa dichiarata astratta e lasci il metodo alle proprie figlie:

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

Il pattern template method

Il motivo più comune per scrivere una classe astratta: una sequenza fissa di passaggi in cui alcuni passaggi cambiano. La classe base possiede la sequenza in un metodo final, e le figlie completano i passaggi. Qui lo stesso report viene prodotto come testo semplice e come tabella 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>';

Eseguilo e la scheda Page mostra la tabella HTML sopra la versione in testo semplice. open() e close() hanno un corpo di default, quindi solo HtmlReport si preoccupa di sovrascriverli; row() è astratto perché non esiste un default sensato. Rendere render() final impedisce a una figlia di cambiare l'ordine dei passaggi.

Una classe astratta può implementare un'interfaccia

Una classe astratta può dichiarare implements e lasciare alcuni metodi dell'interfaccia alle sue figlie. È il modo standard di abbinare un'interfaccia (il tipo) a una classe base (il codice condiviso):

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

Il codice usa come type hint l'interfaccia Cache, quindi una classe che non può estendere BaseCache (perché estende già qualcos'altro) può comunque implementare direttamente Cache.

Quando usare una classe astratta, e quando no

Usa una classe astratta quando le classi di una famiglia condividono codice reale: proprietà, un costruttore, metodi uguali per tutte. Se la base contenesse solo metodi astratti, sarebbe un'interfaccia travestita, e un'interfaccia è la scelta migliore perché una classe può implementare molte interfacce ma estendere una sola classe. Se vuoi solo condividere qualche metodo di supporto tra classi non correlate, usa un trait invece di forzarle sotto un unico padre.

Un test rapido prima di scrivere abstract class: ogni figlia sarebbe davvero un tipo della base (Circle è uno Shape)? Se la risposta onesta è "sa fare questo" invece di "è uno di questi", scrivi un'interfaccia.