מחלקה מופשטת ב-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

תבנית template method

הסיבה הנפוצה ביותר לכתוב מחלקה מופשטת: רצף קבוע של צעדים שבו כמה צעדים שונים. מחלקת הבסיס מחזיקה את הרצף במתודה 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>';

הריצו את זה והלשונית Page תציג את טבלת ה-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)? אם התשובה הכנה היא "היא יודעת לעשות את זה" ולא "היא אחת מאלה", כתבו ממשק.