PHP 抽象类：抽象方法与使用场景

PHP 抽象类用 abstract class Name 声明，不能用 new 创建。它是其他类的基类：可以有属性、构造函数和完整的方法，还可以有没有方法体的 abstract 方法，每个子类都必须实现它们。

<?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() 只在 Shape 中写了一次，它调用的 area() 由每个子类提供。抽象类保证了这个方法一定存在，所以 describe() 可以放心地依赖它。

不能用 new 创建抽象类

抽象类是故意不完整的：Shape::area() 没有方法体，所以一个普通的 Shape 对象没有可运行的东西。PHP 拒绝创建它，并抛出一个 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());

抽象方法的规则

抽象方法只有签名，后面跟一个分号，没有方法体。每个子类都必须用兼容的签名实现它，可见性要相同或更宽：abstract protected 方法在子类中可以变成 protected 或 public，但永远不能是 private。只要一个类有一个抽象方法，它本身就必须声明为抽象类。

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

如果子类漏掉了某个抽象方法，脚本会在任何代码运行之前就停下来，除非这个子类也声明为抽象类，把这个方法留给它自己的子类去实现：

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

模板方法模式

编写抽象类最常见的原因：一组固定顺序的步骤，其中少数几步各不相同。基类用一个 final 方法掌控整个顺序，子类负责填写各个步骤。下面同一份报表分别以纯文本和 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>';

运行它，“页面”标签页会在纯文本版本上方显示 HTML 表格。open() 和 close() 有默认的方法体，所以只有 HtmlReport 需要重写它们；row() 是抽象的，因为它没有合理的默认实现。把 render() 设为 final，可以防止子类改变步骤的顺序。

抽象类可以实现接口

抽象类可以声明 implements，并把接口中的部分方法留给它的子类实现。这是把接口（类型）和基类（共享代码）搭配使用的标准方式：

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

代码的类型声明用的是接口 Cache，所以一个无法继承 BaseCache 的类（因为它已经继承了别的类）仍然可以直接实现 Cache。

什么时候用抽象类，什么时候不用

当一组类共享真正的代码时，就用抽象类：属性、构造函数、对它们都一样的方法。如果基类里除了抽象方法什么都没有，它其实就是一个伪装的接口，而接口是更好的选择，因为一个类可以实现多个接口，却只能继承一个类。如果你只是想在互不相关的类之间共享几个辅助方法，就用 trait，而不是硬把它们塞到同一个父类下面。

写 abstract class 之前先做个简单的测试：每个子类真的都是基类的一种吗（Circle 是一种 Shape）？如果诚实的回答是“它能做这件事”，而不是“它是其中一种”，那就写接口。