Kế thừa trong PHP: extends, parent:: và ghi đè

Trong PHP, một lớp kế thừa (inheritance) lớp khác bằng extends: class Dog extends Animal cho Dog mọi thuộc tính và phương thức public, protected của Animal. Lớp con có thể thêm phương thức mới, ghi đè (override) phương thức được kế thừa bằng cách khai báo phương thức cùng tên, và gọi bản gốc bằng 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 không có hàm khởi tạo nên nó dùng hàm khởi tạo của Animal, vì thế new Dog('Rex') chạy được. Một lớp con chỉ có thể extends một lớp cha; PHP không có đa kế thừa lớp.

Gọi phương thức lớp cha bằng parent::

Ghi đè sẽ thay thế hoàn toàn phương thức của lớp cha. Để mở rộng thay vì thay thế, hãy gọi parent::method() từ lớp con rồi xây dựng tiếp trên kết quả của nó:

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

Cách này cũng dùng được với hàm khởi tạo qua parent::__construct(...), được trình bày ở trang hàm khởi tạo, kể cả chuyện gì xảy ra khi bạn quên gọi nó.

protected và private trong lớp con

Thành viên protected bị ẩn với code bên ngoài nhưng hiển thị với mọi lớp trong cùng họ. Thành viên private chỉ hiển thị trong lớp khai báo nó, nên lớp con hoàn toàn không thấy:

<?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) là false trong lớp con vì lớp con không có quyền truy cập $pin private của lớp cha, trong khi phương thức hasPin() của chính lớp cha vẫn đọc được nó. Dùng protected cho những gì lớp con được phép xây dựng tiếp, và private cho những chi tiết bạn muốn giữ quyền tự do thay đổi.

Đa hình và instanceof

Code viết theo kiểu của lớp cha chạy được với mọi lớp con. Mỗi đối tượng chạy phiên bản riêng của phương thức bị ghi đè, nên chỉ một vòng lặp là xử lý được tất cả. instanceof kiểm tra xem một đối tượng có thuộc một lớp hoặc bất kỳ lớp con nào của lớp đó không:

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

Khi lớp cha không bao giờ nên được dùng riêng (một Shape trơn với diện tích bằng 0 chẳng có mấy ý nghĩa), hãy biến nó thành lớp trừu tượng và khai báo area() là abstract.

Quy tắc ghi đè: chữ ký phải tương thích

Phương thức ghi đè phải nhận được ít nhất những gì lớp cha nhận và trả về thứ mà nơi gọi lớp cha dùng được. Bạn có thể thêm tham số tùy chọn, mở rộng kiểu của tham số hoặc thu hẹp kiểu trả về; bạn không thể thêm tham số bắt buộc hay biến một phương thức public thành private.

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

Đổi string $sep = ',' thành string $sep bắt buộc là PHP từ chối biên dịch lớp với một lỗi nghiêm trọng ("Declaration of CsvExporter::export(array $rows, string$sep): string must be compatible with Exporter::export(array $rows): string").

Lớp và phương thức final

final chặn việc kế thừa tại điểm đó. Phương thức final không thể bị ghi đè, còn final class không thể được kế thừa. Cả hai đều được kiểm tra khi file được biên dịch, nên script hoàn toàn không khởi chạy:

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

Với lớp final, thông báo là Class B cannot extend final class A. Hãy đánh dấu một phương thức là final khi lớp cha dựa vào việc nó hoạt động đúng một cách duy nhất, ví dụ một phương thức kiểm tra quyền trước khi làm bất cứ việc gì khác.

Cái bẫy phương thức private

Phương thức private không được kế thừa, nên phương thức cùng tên ở lớp con không ghi đè nó. Code trong lớp cha vẫn tiếp tục gọi phiên bản private của chính nó, điều khiến nhiều người bất ngờ khi họ tưởng phương thức của lớp con sẽ chạy:

<?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() vẫn in ra Hello: $this->word() của lớp cha trỏ tới phương thức private của lớp cha. Đổi private thành protected trong Greeter rồi chạy lại; giờ phương thức của lớp con là một phép ghi đè thật sự và greet() nói Bonjour.