Classe abstraite PHP : méthodes abstraites et usages

Une classe abstraite PHP se déclare avec abstract class Name et ne peut pas être créée avec new. C'est une base pour d'autres classes : elle peut avoir des propriétés, un constructeur et des méthodes terminées, plus des méthodes abstract sans corps, que chaque classe enfant doit implémenter.

<?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() est écrite une fois dans Shape et appelle area(), que fournit chaque enfant. La classe abstraite garantit que la méthode existe, donc describe() peut compter dessus.

On ne peut pas créer une classe abstraite avec new

Une classe abstraite est incomplète volontairement : Shape::area() n'a pas de corps, donc un simple objet Shape n'aurait rien à exécuter. PHP refuse d'en créer un et lève une 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());

Méthodes abstraites : les règles

Une méthode abstraite a une signature et un point-virgule au lieu d'un corps. Chaque enfant doit l'implémenter avec une signature compatible et une visibilité identique ou plus large : une méthode abstract protected peut devenir protected ou public dans l'enfant, jamais private. Une classe qui a ne serait-ce qu'une méthode abstraite doit elle-même être déclarée abstraite.

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

Un enfant qui oublie une méthode abstraite arrête le script avant qu'une seule ligne s'exécute, sauf si l'enfant est lui aussi déclaré abstrait et laisse la méthode à ses propres enfants :

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

Le patron de méthode

La raison la plus courante d'écrire une classe abstraite : une suite d'étapes fixe dont quelques étapes diffèrent. La classe de base possède la suite dans une méthode final, et les enfants remplissent les étapes. Ici, le même rapport sort en texte brut et en tableau 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>';

Exécutez-le et l'onglet Page affiche le tableau HTML au-dessus de la version texte. open() et close() ont des corps par défaut, donc seul HtmlReport prend la peine de les redéfinir ; row() est abstraite car il n'y a pas de comportement par défaut raisonnable. Rendre render() final empêche un enfant de changer l'ordre des étapes.

Une classe abstraite peut implémenter une interface

Une classe abstraite peut déclarer implements et laisser certaines méthodes de l'interface à ses enfants. C'est la façon standard d'associer une interface (le type) à une classe de base (le code partagé) :

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

Le code type avec l'interface Cache, donc une classe qui ne peut pas étendre BaseCache (parce qu'elle étend déjà autre chose) peut toujours implémenter Cache directement.

Quand utiliser une classe abstraite, et quand ne pas le faire

Prenez une classe abstraite quand les classes d'une famille partagent du vrai code : propriétés, constructeur, méthodes identiques pour toutes. Si la base ne contiendrait que des méthodes abstraites, c'est une interface déguisée, et une interface est le meilleur choix, car une classe peut implémenter plusieurs interfaces mais n'étendre qu'une classe. Si vous voulez seulement partager quelques méthodes utilitaires entre des classes sans rapport, utilisez un trait au lieu de les forcer sous un même parent.

Un test rapide avant d'écrire abstract class : chaque enfant serait-il vraiment une sorte de la base (Circle est une Shape) ? Si la réponse honnête est « il sait faire ceci » plutôt que « il est l'un de ceux-là », écrivez une interface.