Inheritance PHP: extends, parent::, dan Override

Di PHP sebuah class mewarisi class lain dengan extends: class Dog extends Animal memberi Dog setiap property dan method public serta protected milik Animal. Child class bisa menambahkan method baru, meng-override method yang diwarisi dengan mendeklarasikan method bernama sama, dan memanggil versi aslinya dengan 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 tidak punya constructor, jadi ia memakai constructor milik Animal, itulah sebabnya new Dog('Rex') berfungsi. Sebuah child class hanya bisa meng-extend satu parent; PHP tidak punya multiple inheritance untuk class.

Memanggil method parent dengan parent::

Override mengganti method parent sepenuhnya. Untuk memperluasnya alih-alih menggantinya, panggil parent::method() dari child lalu kembangkan hasilnya:

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

Hal yang sama berlaku untuk constructor dengan parent::__construct(...), yang dibahas di halaman constructor, termasuk apa yang terjadi kalau kamu lupa menulisnya.

protected vs private di child class

Member protected tersembunyi dari kode luar tetapi terlihat oleh setiap class dalam satu keluarga. Member private hanya terlihat di class yang mendeklarasikannya, jadi child class sama sekali tidak bisa melihatnya:

<?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) bernilai false di child karena child tidak punya akses ke $pin private milik parent, sedangkan method milik parent sendiri, hasPin(), tetap bisa membacanya. Pakai protected untuk hal yang memang dimaksudkan sebagai dasar bagi subclass, dan private untuk detail yang ingin tetap bebas kamu ubah.

Polimorfisme dan instanceof

Kode yang ditulis untuk tipe parent bekerja dengan setiap child. Setiap object menjalankan versinya sendiri dari method yang di-override, jadi satu loop bisa menangani semuanya. instanceof memeriksa apakah sebuah object berasal dari suatu class atau salah satu turunannya:

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

Jika parent tidak pernah dimaksudkan untuk dipakai sendirian (Shape biasa dengan luas 0 kurang masuk akal), jadikan sebagai abstract class dan deklarasikan area() sebagai abstract.

Aturan override: signature harus tetap kompatibel

Method yang meng-override harus menerima setidaknya apa yang diterima parent dan mengembalikan sesuatu yang bisa dipakai oleh pemanggil parent. Kamu boleh menambahkan parameter opsional, memperluas tipe parameter, atau mempersempit tipe return; kamu tidak boleh menambahkan parameter wajib atau menjadikan method public menjadi 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";

Ubah string $sep = ',' menjadi string $sep yang wajib, maka PHP menolak mengompilasi class itu dengan fatal error ("Declaration of CsvExporter::export(array $rows, string$sep): string must be compatible with Exporter::export(array $rows): string").

Class dan method final

final menghentikan pewarisan di titik itu. Method final tidak bisa di-override, dan final class tidak bisa di-extend. Keduanya diperiksa saat file dikompilasi, jadi script sama sekali tidak dimulai:

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

Untuk class final, pesannya adalah Class B cannot extend final class A. Tandai sebuah method sebagai final saat parent bergantung pada perilakunya yang harus persis satu cara, misalnya method yang memeriksa izin sebelum melakukan hal lain.

Jebakan method private

Method private tidak diwariskan, jadi method child dengan nama yang sama tidak meng-override-nya. Kode di parent tetap memanggil versi private miliknya sendiri, yang mengejutkan orang yang mengira method child yang akan berjalan:

<?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() tetap mencetak Hello: $this->word() di parent mengarah ke method private milik parent. Ubah private menjadi protected di Greeter lalu jalankan lagi; sekarang method child benar-benar meng-override dan greet() mengucapkan Bonjour.