Classe abstrata em PHP: métodos abstratos e quando usar

Uma classe abstrata PHP é declarada com abstract class Name e não pode ser criada com new. Ela é uma base para outras classes: pode ter propriedades, um construtor e métodos prontos, mais métodos abstract sem corpo, que toda classe filha precisa 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() é escrito uma vez em Shape e chama area(), que cada filha fornece. A classe abstrata garante que o método existe, então describe() pode confiar nele.

Não dá para criar uma classe abstrata com new

Uma classe abstrata é incompleta de propósito: Shape::area() não tem corpo, então um objeto Shape simples não teria nada para executar. O PHP se recusa a criar um e lança um 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 abstratos: as regras

Um método abstrato tem uma assinatura e um ponto e vírgula no lugar do corpo. Cada filha precisa implementá-lo com uma assinatura compatível e a mesma visibilidade ou uma mais ampla: um método abstract protected pode virar protected ou public na filha, nunca private. Uma classe com um único método abstrato que seja precisa ela mesma ser declarada abstrata.

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

Uma filha que pula um método abstrato interrompe o script antes de qualquer parte dele rodar, a menos que a filha também seja declarada abstrata e deixe o método para as próprias filhas:

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

O padrão template method

O motivo mais comum para escrever uma classe abstrata: uma sequência fixa de passos em que alguns passos mudam. A classe base é dona da sequência num método final, e as filhas preenchem os passos. Aqui o mesmo relatório sai como texto puro e como 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>';

Rode e a aba Page mostra a tabela HTML acima da versão em texto puro. open() e close() têm corpo padrão, então só HtmlReport se dá ao trabalho de sobrescrevê-los; row() é abstrato porque não existe um padrão razoável. Tornar render() final impede que uma filha mude a ordem dos passos.

Uma classe abstrata pode implementar uma interface

Uma classe abstrata pode declarar implements e deixar alguns métodos da interface para as filhas. É o jeito padrão de combinar uma interface (o tipo) com uma classe base (o código compartilhado):

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

O código usa o type hint da interface Cache, então uma classe que não pode estender BaseCache (porque já estende outra coisa) ainda pode implementar Cache diretamente.

Quando usar uma classe abstrata, e quando não usar

Use uma classe abstrata quando as classes de uma família compartilham código de verdade: propriedades, um construtor, métodos iguais para todas. Se a base não tiver nada além de métodos abstratos, ela é uma interface disfarçada, e uma interface é a melhor escolha, porque uma classe pode implementar várias interfaces mas só estender uma classe. Se você só quer compartilhar alguns métodos auxiliares entre classes sem relação entre si, use uma trait em vez de forçá-las sob uma única classe pai.

Um teste rápido antes de escrever abstract class: cada filha seria mesmo um tipo da base (Circle é um Shape)? Se a resposta honesta for "ela consegue fazer isto" em vez de "ela é um destes", escreva uma interface.