ירושה ב-PHP: extends, parent:: ודריסת מתודות

ב-PHP מחלקה יורשת ממחלקה אחרת עם extends: class Dog extends Animal נותנת ל-Dog כל מאפיין ומתודה ציבוריים ומוגנים של Animal. הבת יכולה להוסיף מתודות חדשות, לדרוס מתודות שירשה על ידי הצהרה על מתודה עם אותו שם, ולקרוא למקור עם parent::method().

<?php
class Animal
{
    public function __construct(protected string $name) {}

    public function speak(): string
    {
        return "{$this->name} makes a sound";
    }

    public function name(): string
    {
        return $this->name;
    }
}

class Dog extends Animal
{
    public function speak(): string
    {
        return "{$this->name} barks";
    }

    public function fetch(): string
    {
        return "{$this->name} brings the ball back";
    }
}

$generic = new Animal('Some animal');
$rex = new Dog('Rex');

echo $generic->speak(), "\n";
echo $rex->speak(), "\n";     // overridden
echo $rex->name(), "\n";      // inherited
echo $rex->fetch(), "\n";     // added

ל-Dog אין בנאי, ולכן היא משתמשת בזה של Animal, וזו הסיבה ש-new Dog('Rex') עובד. מחלקת בת יכולה להרחיב רק אב אחד; אין ב-PHP ירושה מרובה של מחלקות.

קריאה למתודה של האב עם parent::

דריסה מחליפה את המתודה של האב לגמרי. כדי להרחיב אותה במקום להחליף, קראו ל-parent::method() מהבת ובנו על התוצאה שלה:

<?php
class Report
{
    public function header(): string
    {
        return "Sales report";
    }

    public function lines(): array
    {
        return ['Q1: 120', 'Q2: 98'];
    }
}

class DetailedReport extends Report
{
    public function header(): string
    {
        return parent::header() . " (detailed)";
    }

    public function lines(): array
    {
        $lines = parent::lines();
        $lines[] = 'Total: 218';
        return $lines;
    }
}

$r = new DetailedReport();
echo $r->header(), "\n";
echo implode("\n", $r->lines()), "\n";

אותו הדבר עובד לבנאים עם parent::__construct(...), שמוסבר בעמוד הבנאי, כולל מה שקורה כששוכחים אותו.

protected מול private במחלקות בת

חבר protected מוסתר מקוד חיצוני אבל גלוי לכל מחלקה במשפחה. חבר private גלוי רק במחלקה שמצהירה עליו, ולכן מחלקת בת לא רואה אותו בכלל:

<?php
class BankAccount
{
    protected float $balance = 100;
    private string $pin = '1234';

    public function hasPin(): bool
    {
        return $this->pin !== '';
    }
}

class SavingsAccount extends BankAccount
{
    public function addInterest(float $rate): void
    {
        $this->balance *= 1 + $rate;   // protected: allowed
    }

    public function balance(): float
    {
        return $this->balance;
    }

    public function pinKnown(): bool
    {
        return isset($this->pin);      // private in the parent: not visible here
    }
}

$s = new SavingsAccount();
$s->addInterest(0.05);
echo $s->balance(), "\n";
var_dump($s->pinKnown(), $s->hasPin());

isset($this->pin) הוא false בבת כי לבת אין גישה ל-$pin הפרטי של האב, בעוד המתודה של האב עצמו, hasPin(), עדיין קוראת אותו. השתמשו ב-protected למה שמחלקות בת אמורות לבנות עליו, וב-private לפרטים שאתם רוצים להשאיר חופשיים לשינוי.

פולימורפיזם ו-instanceof

קוד שנכתב מול טיפוס האב עובד עם כל בת. כל אובייקט מריץ את הגרסה שלו של מתודה שנדרסה, ולכן לולאה אחת מטפלת בכולם. instanceof בודק אם אובייקט שייך למחלקה או לאחת מבנותיה:

<?php
class Shape
{
    public function area(): float
    {
        return 0;
    }
}

class Rectangle extends Shape
{
    public function __construct(private float $w, private float $h) {}

    public function area(): float
    {
        return $this->w * $this->h;
    }
}

class Circle extends Shape
{
    public function __construct(private float $r) {}

    public function area(): float
    {
        return M_PI * $this->r ** 2;
    }
}

function totalArea(Shape ...$shapes): float
{
    return array_sum(array_map(fn (Shape $s) => $s->area(), $shapes));
}

$shapes = [new Rectangle(3, 4), new Circle(1), new Rectangle(2, 2)];
printf("Total area: %.2f\n", totalArea(...$shapes));

foreach ($shapes as $s) {
    echo get_class($s), ': ', $s instanceof Shape ? 'is a Shape' : 'not a Shape';
    echo $s instanceof Circle ? ', is a Circle' : '', "\n";
}
echo get_parent_class(new Circle(2)), "\n";

כשאסור להשתמש באב לבדו (Shape רגיל עם שטח 0 לא הגיוני במיוחד), הפכו אותו למחלקה מופשטת והצהירו על area() כמופשטת.

כללי דריסה: החתימות חייבות להישאר תואמות

מתודה דורסת חייבת לקבל לפחות את מה שהאב קיבל ולהחזיר משהו שהקוראים של האב יכולים להשתמש בו. אפשר להוסיף פרמטר אופציונלי, להרחיב טיפוס של פרמטר או לצמצם טיפוס החזרה; אי אפשר להוסיף פרמטר חובה או להפוך מתודה ציבורית לפרטית.

<?php
class Exporter
{
    public function export(array $rows): string
    {
        return implode(';', array_map(fn ($r) => implode(',', $r), $rows));
    }
}

class CsvExporter extends Exporter
{
    // Adds an optional parameter: compatible
    public function export(array $rows, string $sep = ','): string
    {
        return implode("\n", array_map(fn ($r) => implode($sep, $r), $rows));
    }
}

$rows = [['id', 'name'], [1, 'Ada'], [2, 'Linus']];
echo (new Exporter())->export($rows), "\n\n";
echo (new CsvExporter())->export($rows), "\n\n";
echo (new CsvExporter())->export($rows, "\t"), "\n";

שנו את string $sep = ',' ל-string $sep חובה ו-PHP תסרב להדר את המחלקה עם שגיאה קטלנית ("Declaration of CsvExporter::export(array $rows, string$sep): string must be compatible with Exporter::export(array $rows): string").

מחלקות ומתודות final

final עוצר את הירושה בנקודה הזו. מתודה final אי אפשר לדרוס, ו-final class אי אפשר להרחיב. שניהם נבדקים כשהקובץ מהודר, ולכן הסקריפט לא מתחיל בכלל:

<?php
class Payment
{
    final public function charge(int $cents): string
    {
        return "charged $cents";
    }
}

class FreePayment extends Payment
{
    public function charge(int $cents): string
    {
        return 'free';
    }
}

PHP Fatal error:  Cannot override final method Payment::charge() in /home/index.php on line 12

למחלקה final ההודעה היא Class B cannot extend final class A. סמנו מתודה כ-final כשהאב מסתמך על כך שהיא תתנהג בדיוק בדרך אחת, למשל מתודה שבודקת הרשאות לפני שהיא עושה כל דבר אחר.

המלכודת של מתודה פרטית

מתודה פרטית לא עוברת בירושה, ולכן מתודה בבת עם אותו שם לא דורסת אותה. קוד באב ממשיך לקרוא לגרסה הפרטית שלו, וזה מפתיע אנשים שמצפים שהמתודה של הבת תרוץ:

<?php
class Greeter
{
    public function greet(): string
    {
        return $this->word() . ', world';
    }

    private function word(): string
    {
        return 'Hello';
    }
}

class FrenchGreeter extends Greeter
{
    public function word(): string
    {
        return 'Bonjour';
    }
}

echo (new FrenchGreeter())->greet(), "\n";
echo (new FrenchGreeter())->word(), "\n";

greet() עדיין מדפיסה Hello: ה-$this->word() של האב מתפרש כמתודה הפרטית של האב. שנו את private ל-protected ב-Greeter והריצו שוב; עכשיו המתודה של הבת היא דריסה אמיתית ו-greet() אומרת Bonjour.