Clase abstracta en PHP: métodos abstractos y cuándo usarla

Una clase abstracta de PHP se declara con abstract class Name y no se puede crear con new. Es una base para otras clases: puede tener propiedades, un constructor y métodos terminados, además de métodos abstract sin cuerpo, que cada clase hija debe implementar.

<?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() se escribe una vez en Shape y llama a area(), que aporta cada hija. La clase abstracta garantiza que el método existe, así que describe() puede contar con él.

No puedes crear una clase abstracta con new

Una clase abstracta está incompleta a propósito: Shape::area() no tiene cuerpo, así que un objeto Shape a secas no tendría nada que ejecutar. PHP se niega a crear uno y lanza 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());

Métodos abstractos: las reglas

Un método abstracto tiene una firma y un punto y coma en lugar de cuerpo. Cada hija debe implementarlo con una firma compatible y la misma visibilidad o una más amplia: un método abstract protected puede ser protected o public en la hija, nunca private. Una clase con un solo método abstracto ya debe declararse abstracta.

<?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 hija que se salta un método abstracto detiene el script antes de que se ejecute nada, salvo que la hija también se declare abstracta y deje el método a sus propias hijas:

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

El patrón template method

El motivo más habitual para escribir una clase abstracta: una secuencia fija de pasos en la que unos pocos cambian. La clase base es dueña de la secuencia en un método final, y las hijas rellenan los pasos. Aquí el mismo informe se genera como texto plano y como tabla 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>';

Ejecútalo y la pestaña Página muestra la tabla HTML encima de la versión en texto plano. open() y close() tienen cuerpos por defecto, así que solo HtmlReport se molesta en sobrescribirlos; row() es abstracto porque no hay un valor por defecto razonable. Hacer render() final impide que una hija cambie el orden de los pasos.

Una clase abstracta puede implementar una interfaz

Una clase abstracta puede declarar implements y dejar algunos de los métodos de la interfaz para sus hijas. Es la forma estándar de emparejar una interfaz (el tipo) con una clase base (el código compartido):

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

El código usa la interfaz Cache como declaración de tipo, así que una clase que no puede extender BaseCache (porque ya extiende otra cosa) puede seguir implementando Cache directamente.

Cuándo usar una clase abstracta y cuándo no

Recurre a una clase abstracta cuando las clases de una familia comparten código real: propiedades, un constructor, métodos iguales para todas. Si la base no contuviera más que métodos abstractos, sería una interfaz disfrazada, y una interfaz es la mejor opción porque una clase puede implementar muchas interfaces pero extender solo una clase. Si solo quieres compartir unos cuantos métodos auxiliares entre clases no relacionadas, usa un trait en lugar de forzarlas bajo un mismo padre.

Una prueba rápida antes de escribir abstract class: ¿cada hija sería realmente un tipo de la base (Circle es un Shape)? Si la respuesta sincera es "puede hacer esto" y no "es uno de estos", escribe una interfaz.