PHP Kalıtım: extends, parent:: ve Metot Ezme

PHP'de bir sınıf başka bir sınıftan extends ile kalıtım alır: class Dog extends Animal Dog sınıfına Animal sınıfının her public ve protected özelliğini ve metodunu verir. Alt sınıf yeni metotlar ekleyebilir, aynı adla bir metot tanımlayarak kalıtılanları ezebilir ve orijinali parent::method() ile çağırabilir.

<?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 sınıfının yapıcısı yoktur, bu yüzden Animal sınıfınınkini kullanır; new Dog('Rex') ifadesinin çalışmasının nedeni budur. Bir alt sınıf yalnızca bir üst sınıfı genişletebilir; PHP'de sınıflar için çoklu kalıtım yoktur.

Üst sınıfın metodunu parent:: ile çağırma

Ezme, üst sınıfın metodunu tamamen değiştirir. Değiştirmek yerine genişletmek için alt sınıftan parent::method() çağırın ve sonucunun üzerine inşa edin:

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

Aynısı yapıcılar için parent::__construct(...) ile çalışır; yapıcı sayfası onu unuttuğunuzda ne olduğu dahil bunu anlatır.

Alt sınıflarda protected ile private

Bir protected üye dışarıdaki koddan gizlidir ama ailedeki her sınıf tarafından görülür. Bir private üye yalnızca onu tanımlayan sınıfta görülür, bu yüzden bir alt sınıf onu hiç göremez:

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

Alt sınıfta isset($this->pin) false olur, çünkü alt sınıfın üst sınıfın private $pin özelliğine erişimi yoktur; üst sınıfın kendi metodu hasPin() ise onu hâlâ okur. Alt sınıfların üzerine inşa etmesi amaçlanan şeyler için protected, değiştirme özgürlüğünü korumak istediğiniz ayrıntılar için private kullanın.

Çok biçimlilik ve instanceof

Üst sınıf türüne göre yazılmış kod her alt sınıfla çalışır. Her nesne ezilmiş bir metodun kendi sürümünü çalıştırır, bu yüzden tek bir döngü hepsini işler. instanceof bir nesnenin bir sınıftan veya onun herhangi bir alt sınıfından olup olmadığını kontrol eder:

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

Üst sınıfın tek başına asla kullanılmaması gerektiğinde (alanı 0 olan düz bir Shape pek anlamlı değildir), onu bir soyut sınıf yapın ve area() metodunu soyut olarak tanımlayın.

Ezme kuralları: imzalar uyumlu kalmalı

Ezen bir metot en az üst sınıfın kabul ettiğini kabul etmeli ve üst sınıfı çağıranların kullanabileceği bir şey döndürmelidir. İsteğe bağlı bir parametre ekleyebilir, bir parametre türünü genişletebilir veya bir dönüş türünü daraltabilirsiniz; zorunlu bir parametre ekleyemez veya public bir metodu private yapamazsınız.

<?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 = ',' ifadesini zorunlu bir string $sep yapın, PHP sınıfı ölümcül bir hatayla derlemeyi reddeder ("Declaration of CsvExporter::export(array $rows, string$sep): string must be compatible with Exporter::export(array $rows): string").

final sınıflar ve metotlar

final kalıtımı o noktada durdurur. Bir final metot ezilemez ve bir final class genişletilemez. İkisi de dosya derlenirken kontrol edilir, bu yüzden betik hiç başlamaz:

<?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 bir sınıf için mesaj Class B cannot extend final class A olur. Üst sınıf bir metodun tam olarak tek bir şekilde davranmasına dayandığında, örneğin başka bir şey yapmadan önce izinleri kontrol eden bir metotta, metodu final olarak işaretleyin.

private metot tuzağı

Private bir metot kalıtılmaz, bu yüzden aynı adlı bir alt sınıf metodu onu ezmez. Üst sınıftaki kod kendi private sürümünü çağırmaya devam eder; bu da alt sınıfın metodunun çalışmasını bekleyenleri şaşırtır:

<?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() hâlâ Hello yazdırır: üst sınıfın $this->word() çağrısı üst sınıfın private metoduna çözümlenir. Greeter içinde private ifadesini protected yapın ve tekrar çalıştırın; artık alt sınıfın metodu gerçek bir ezmedir ve greet() Bonjour der.