Abstract class trong PHP: abstract method, khi nào dùng

Abstract class trong PHP được khai báo bằng abstract class Name và không thể tạo bằng new. Nó làm nền cho các lớp (class) khác: có thể chứa thuộc tính, hàm khởi tạo và các phương thức hoàn chỉnh, cùng các phương thức abstract không có thân mà mọi lớp con phải cài đặt.

<?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() chỉ được viết một lần trong Shape và gọi area(), phương thức do từng lớp con cung cấp. Abstract class đảm bảo phương thức đó tồn tại, nên describe() có thể dựa vào nó.

Không thể tạo abstract class bằng new

Abstract class được cố ý để dở dang: Shape::area() không có thân, nên một đối tượng Shape thuần sẽ không có gì để chạy. PHP từ chối tạo nó và ném ra 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 method: các quy tắc

Một abstract method có chữ ký và một dấu chấm phẩy thay cho thân hàm. Mỗi lớp con phải cài đặt nó với chữ ký tương thích và phạm vi truy cập bằng hoặc rộng hơn: một phương thức abstract protected có thể trở thành protected hoặc public ở lớp con, nhưng không bao giờ là private. Một lớp chỉ cần có một abstract method là bản thân nó phải được khai báo abstract.

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

Một lớp con bỏ sót abstract method sẽ khiến script dừng trước khi bất kỳ dòng nào kịp chạy, trừ khi lớp con đó cũng được khai báo abstract và để phương thức lại cho các lớp con của 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

Mẫu template method

Lý do phổ biến nhất để viết một abstract class: có một chuỗi bước cố định, trong đó chỉ vài bước khác nhau. Lớp cơ sở nắm giữ thứ tự các bước trong một phương thức final, còn các lớp con điền vào từng bước. Ở đây cùng một báo cáo được xuất ra dưới dạng văn bản thuần và dạng bảng 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>';

Chạy code và tab Trang hiển thị bảng HTML phía trên phiên bản văn bản thuần. open() và close() có thân mặc định, nên chỉ HtmlReport cần ghi đè chúng; row() là abstract vì không có giá trị mặc định nào hợp lý. Đặt render() là final để lớp con không thể thay đổi thứ tự các bước.

Abstract class có thể cài đặt interface

Một abstract class có thể khai báo implements và để lại một số phương thức của interface cho các lớp con. Đây là cách chuẩn để ghép một interface (kiểu) với một lớp cơ sở (phần code dùng chung):

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

Code khai báo kiểu bằng interface Cache, nên một lớp không thể kế thừa BaseCache (vì đã kế thừa một lớp khác) vẫn có thể cài đặt Cache trực tiếp.

Khi nào nên và không nên dùng abstract class

Hãy dùng abstract class khi các lớp trong cùng một họ dùng chung code thật sự: thuộc tính, hàm khởi tạo, các phương thức giống nhau cho tất cả. Nếu lớp cơ sở chỉ toàn abstract method, thực chất nó là một interface trá hình, và interface là lựa chọn tốt hơn vì một lớp có thể cài đặt nhiều interface nhưng chỉ kế thừa được một lớp. Nếu bạn chỉ muốn chia sẻ vài phương thức tiện ích giữa các lớp không liên quan, hãy dùng trait thay vì ép chúng chung một lớp cha.

Một phép thử nhanh trước khi viết abstract class: liệu mọi lớp con có thật sự là một loại của lớp cơ sở không (Circle là một Shape)? Nếu câu trả lời thật lòng là "nó làm được việc này" chứ không phải "nó là một trong số này", hãy viết interface.