Lekcja 26 (OOP 6): Dziedziczenie (extends), Nadpisywanie Metod, Słowo Kluczowe final

Witaj w szóstej lekcji naszego modułu o Programowaniu Obiektowym w PHP! W poprzednich lekcjach poznaliśmy podstawy OOP, nauczyliśmy się tworzyć klasy i obiekty, zarządzać dostępem do ich składowych za pomocą modyfikatorów dostępu oraz korzystać ze składowych statycznych. Dzisiaj zajmiemy się jednym z najważniejszych i najpotężniejszych mechanizmów OOP: dziedziczeniem (inheritance). Dziedziczenie pozwala na tworzenie nowych klas (nazywanych klasami potomnymi lub podklasami) na bazie istniejących klas (nazywanych klasami bazowymi, nadrzędnymi lub nadklasami), co promuje reużywalność kodu i tworzenie hierarchii klas.

Omówimy, jak w PHP implementuje się dziedziczenie za pomocą słowa kluczowego extends, jak klasy potomne dziedziczą właściwości i metody po klasach bazowych, jak można nadpisywać (override) odziedziczone metody, aby dostosować ich zachowanie, oraz jak używać słowa kluczowego parent:: do wywoływania metod z klasy nadrzędnej. Na koniec przyjrzymy się słowu kluczowemu final, które pozwala zapobiegać dziedziczeniu klas lub nadpisywaniu metod.

Czym Jest Dziedziczenie?

Dziedziczenie to mechanizm, który pozwala jednej klasie (klasie potomnej) przejmować (dziedziczyć) właściwości i metody z innej klasy (klasy bazowej). Klasa potomna może następnie dodawać własne, unikalne właściwości i metody, a także modyfikować (nadpisywać) zachowanie odziedziczonych metod. Tworzy to relację "jest rodzajem" (is-a relationship) – na przykład, jeśli mamy klasę Pojazd i klasę Samochod, która dziedziczy po Pojazd, to możemy powiedzieć, że "Samochód jest rodzajem Pojazdu".

Główne korzyści z dziedziczenia:

• Reużywalność kodu (Code Reusability): Wspólne właściwości i metody mogą być zdefiniowane raz w klasie bazowej i automatycznie dostępne we wszystkich klasach potomnych. Unikamy w ten sposób powielania kodu.
• Organizacja kodu i tworzenie hierarchii: Dziedziczenie pozwala na tworzenie logicznych hierarchii klas, odzwierciedlających relacje między różnymi typami obiektów w systemie. Na przykład: Zwierze -> Ssak -> Pies -> Labrador.
• Polimorfizm (Polymorphism): Dziedziczenie jest podstawą polimorfizmu (który omówimy szczegółowo w późniejszej lekcji), czyli zdolności obiektów różnych klas do reagowania na to samo wywołanie metody w sposób specyficzny dla swojej klasy.
• Rozszerzalność (Extensibility): Łatwo jest dodawać nowe funkcjonalności poprzez tworzenie nowych klas potomnych, które dziedziczą istniejące cechy i dodają własne.

W PHP klasa może dziedziczyć tylko po jednej klasie bazowej – PHP nie wspiera wielokrotnego dziedziczenia klas (choć pewne aspekty wielokrotnego dziedziczenia można osiągnąć za pomocą cech – traits, o których powiemy w kolejnej lekcji).

Implementacja Dziedziczenia za Pomocą extends

Aby zadeklarować, że jedna klasa dziedziczy po innej, używamy słowa kluczowego extends.

<?php
// Klasa bazowa (nadrzędna)
class Zwierze
{
    public string $nazwa;
    protected int $wiek = 0;

    public function __construct(string $nazwa)
    {
        $this->nazwa = $nazwa;
        echo "Utworzono obiekt Zwierze: " . $this->nazwa . "<br>";
    }

    public function jedz(string $pokarm): void
    {
        echo $this->nazwa . " je " . $pokarm . ".<br>";
    }

    public function spij(): void
    {
        echo $this->nazwa . " śpi.<br>";
    }

    public function getWiek(): int
    {
        return $this->wiek;
    }

    public function setWiek(int $wiek): void
    {
        if ($wiek >= 0) {
            $this->wiek = $wiek;
        } else {
            echo "Wiek nie może być ujemny.<br>";
        }
    }
}

// Klasa potomna (podklasa) dziedzicząca po Zwierze
class Pies extends Zwierze
{
    public string $rasa;

    // Konstruktor klasy potomnej
    public function __construct(string $nazwa, string $rasa)
    {
        // Wywołanie konstruktora klasy bazowej (Zwierze)
        parent::__construct($nazwa); // `parent::` odnosi się do klasy nadrzędnej
        $this->rasa = $rasa;
        echo "Utworzono obiekt Pies rasy: " . $this->rasa . "<br>";
    }

    // Nowa metoda specyficzna dla klasy Pies
    public function szczekaj(): void
    {
        echo $this->nazwa . " (rasa: " . $this->rasa . ") szczeka: Hau hau!<br>";
    }

    // Nadpisywanie metody jedz z klasy Zwierze
    public function jedz(string $pokarm): void
    {
        if ($pokarm === "czekolada") {
            echo $this->nazwa . " nie może jeść czekolady! To niezdrowe dla psów.<br>";
        } else {
            // Wywołanie oryginalnej metody jedz z klasy Zwierze
            parent::jedz($pokarm);
            echo $this->nazwa . " merda ogonem, bo dostał " . $pokarm . ".<br>";
        }
    }
}

$azor = new Pies("Azor", "Owczarek Niemiecki");
$azor->setWiek(5);

// Metody odziedziczone z Zwierze
$azor->jedz("karma dla psów");
$azor->jedz("czekolada"); // Wywoła nadpisaną metodę
$azor->spij();
echo $azor->nazwa . " ma " . $azor->getWiek() . " lat.<br>";

// Metoda specyficzna dla Pies
$azor->szczekaj();

echo "<hr>";

$mruczek = new Zwierze("Mruczek"); // Zwykły obiekt klasy bazowej
$mruczek->jedz("ryba");
// $mruczek->szczekaj(); // BŁĄD! Fatal error: Call to undefined method Zwierze::szczekaj()
?>

W tym przykładzie:

• Klasa Pies dziedziczy po klasie Zwierze.
• Obiekt $azor (typu Pies) ma dostęp do publicznych właściwości ($nazwa) i metod (jedz, spij, getWiek, setWiek) zdefiniowanych w klasie Zwierze.
• Klasa Pies dodaje własną publiczną właściwość $rasa i własną publiczną metodę szczekaj().
• Konstruktor klasy Pies wywołuje konstruktor klasy Zwierze za pomocą parent::__construct($nazwa). Jest to bardzo ważne, aby zapewnić prawidłową inicjalizację części obiektu pochodzącej z klasy bazowej. Jeśli klasa potomna ma własny konstruktor, konstruktor klasy bazowej nie jest automatycznie wywoływany.
• Klasa Pies nadpisuje metodę jedz() z klasy Zwierze, dostarczając własną implementację. Wewnątrz nadpisanej metody może również wywołać oryginalną implementację z klasy bazowej za pomocą parent::jedz($pokarm).

Co Jest Dziedziczone?

Klasa potomna dziedziczy:

• Wszystkie publiczne i chronione (protected) właściwości i metody klasy bazowej.
• Prywatne (private) właściwości i metody klasy bazowej nie są bezpośrednio dostępne w klasie potomnej (nie można się do nich odwołać za pomocą $this->prywatnaWlasciwosc w klasie potomnej). Jednakże, jeśli publiczne lub chronione metody klasy bazowej używają jej prywatnych składowych, to te metody nadal będą działać poprawnie, gdy zostaną wywołane na obiekcie klasy potomnej. Prywatne składowe pozostają częścią obiektu, ale są dostępne tylko poprzez interfejs klasy, która je zdefiniowała.

Nadpisywanie Metod (Method Overriding)

Nadpisywanie metod to możliwość zdefiniowania w klasie potomnej metody o tej samej nazwie i takiej samej sygnaturze (lub kompatybilnej sygnaturze) co metoda w klasie bazowej. Gdy metoda jest wywoływana na obiekcie klasy potomnej, wykonana zostanie wersja metody z klasy potomnej, a nie z klasy bazowej.

Zasady nadpisywania metod:

• Nazwa metody musi być identyczna.
• Modyfikator dostępu w klasie potomnej musi być taki sam lub mniej restrykcyjny niż w klasie bazowej (np. jeśli metoda w klasie bazowej jest protected, w klasie potomnej może być protected lub public, ale nie private).
• Sygnatura metody (liczba i typy parametrów, typ zwracany) musi być kompatybilna. Od PHP 7.4 (z typowaniem właściwości i typami zwracanymi) obowiązują zasady kowariancji (dla typów zwracanych) i kontrawariancji (dla typów parametrów), co oznacza, że typ zwracany w metodzie nadpisującej może być bardziej szczegółowy, a typy parametrów mogą być bardziej ogólne (lub takie same). W praktyce, dla uproszczenia, często utrzymuje się identyczną sygnaturę.
• Metody zadeklarowane jako final w klasie bazowej nie mogą być nadpisywane (o tym za chwilę).
• Metody statyczne również mogą być "nadpisywane" (a raczej redefiniowane lub ukrywane) w klasach potomnych, ale mechanizm ten działa nieco inaczej niż dla metod instancyjnych i nie podlega polimorfizmowi w ten sam sposób.

W przykładzie z klasą Pies, metoda jedz() została nadpisana:

<?php
// ... (definicja klasy Zwierze jak wyżej)
class Pies extends Zwierze
{
    // ... (reszta klasy Pies)

    // Nadpisywanie metody jedz z klasy Zwierze
    public function jedz(string $pokarm): void // Ta sama nazwa i sygnatura (lub kompatybilna)
    {
        if ($pokarm === "czekolada") {
            echo $this->nazwa . " nie może jeść czekolady! To niezdrowe dla psów.<br>";
        } else {
            // Wywołanie oryginalnej metody jedz z klasy Zwierze
            parent::jedz($pokarm);
            echo $this->nazwa . " merda ogonem, bo dostał " . $pokarm . ".<br>";
        }
    }
}
?>

Gdy wywołamy $azor->jedz("karma dla psów"), wykona się kod z nadpisanej metody w klasie Pies.

Słowo Kluczowe parent::

Słowo kluczowe parent:: pozwala na dostęp do składowych (metod i właściwości statycznych, a także konstruktora) klasy nadrzędnej z wnętrza klasy potomnej.

• parent::__construct(...): Bardzo często używane do wywołania konstruktora klasy bazowej z konstruktora klasy potomnej.
• parent::nazwaMetody(...): Używane do wywołania oryginalnej implementacji metody z klasy bazowej, jeśli została ona nadpisana w klasie potomnej, a chcemy nadal skorzystać z funkcjonalności rodzica.
• parent::$wlasciwoscStatyczna lub parent::STALA_KLASOWA: Dostęp do statycznych właściwości lub stałych klasy nadrzędnej.

parent:: odnosi się zawsze do bezpośredniego rodzica w hierarchii dziedziczenia.

Słowo Kluczowe final

Słowo kluczowe final może być użyte w dwóch kontekstach:

1. Metody Finalne (final function)

Jeśli metoda w klasie bazowej jest zadeklarowana jako final, oznacza to, że nie może być nadpisana w żadnej klasie potomnej. Próba nadpisania metody finalnej spowoduje błąd krytyczny (Fatal error).

<?php
class Urzadzenie
{
    public final function getNumerSeryjny(): string
    {
        // Logika pobierania unikalnego numeru seryjnego, która nie powinna być zmieniana
        return "SN-" . uniqid();
    }

    public function wlacz(): void
    {
        echo "Urzadzenie włączone.<br>";
    }
}

class Komputer extends Urzadzenie
{
    // Próba nadpisania metody finalnej - spowoduje błąd
    /*
    public function getNumerSeryjny(): string 
    {
        return "KOMP-" . parent::getNumerSeryjny();
    }
    */ // To by spowodowało: Fatal error: Cannot override final method Urzadzenie::getNumerSeryjny()

    // Nadpisanie metody niefinalnej jest dozwolone
    public function wlacz(): void
    {
        parent::wlacz();
        echo "System operacyjny komputera startuje...<br>";
    }
}

$mojKomputer = new Komputer();
echo "Numer seryjny komputera: " . $mojKomputer->getNumerSeryjny() . "<br>";
$mojKomputer->wlacz();
?>

Metody finalne są używane, gdy chcemy zagwarantować, że pewna kluczowa część implementacji klasy nie zostanie zmieniona przez klasy potomne, np. ze względów bezpieczeństwa lub integralności.

2. Klasy Finalne (final class)

Jeśli cała klasa jest zadeklarowana jako final, oznacza to, że nie może być ona dziedziczona. Żadna inna klasa nie może użyć jej jako klasy bazowej (nie może po niej extends).

<?php
final class StringUtils
{
    // Klasa z metodami pomocniczymi, nieprzeznaczona do dziedziczenia
    public static function odwracaj(string $tekst): string
    {
        return strrev($tekst);
    }
}

// Próba dziedziczenia po klasie finalnej - spowoduje błąd
/*
class MojeNarzędziaString extends StringUtils 
{
    // ...
}
*/ // To by spowodowało: Fatal error: Class MojeNarzędziaString may not inherit from final class (StringUtils)

echo StringUtils::odwracaj("Hello World") . "<br>";
?>

Klasy finalne są używane, gdy projektant klasy chce jawnie zabronić jej rozszerzania, np. dla klas narzędziowych (utility classes) lub klas, których wewnętrzna spójność mogłaby zostać naruszona przez dziedziczenie.

Konstruktory i Dziedziczenie

Jak wspomniano wcześniej, jeśli klasa potomna definiuje własny konstruktor, konstruktor klasy bazowej nie jest automatycznie wywoływany. Aby go wywołać, należy użyć parent::__construct(...).

Dlaczego to jest ważne? Konstruktor klasy bazowej często wykonuje kluczowe inicjalizacje (np. ustawia odziedziczone właściwości). Jeśli go nie wywołamy, obiekt może nie być w pełni lub poprawnie zainicjalizowany.

Co jeśli klasa potomna nie ma własnego konstruktora? W takim przypadku, jeśli tworzymy obiekt klasy potomnej, automatycznie zostanie wywołany konstruktor z najbliższej klasy nadrzędnej w hierarchii, która posiada konstruktor. Jeśli żadna klasa w hierarchii (aż do samej góry) nie ma konstruktora, to nic specjalnego się nie dzieje (chyba że próbujemy przekazać argumenty do new, co może spowodować błąd, jeśli nie ma pasującego konstruktora).

<?php
class A
{
    public function __construct()
    {
        echo "Konstruktor A<br>";
    }
}

class B extends A
{
    // Brak własnego konstruktora, więc wywoła się konstruktor A
}

class C extends A
{
    public function __construct()
    {
        // parent::__construct(); // Jeśli odkomentujemy, wywoła się też konstruktor A
        echo "Konstruktor C<br>";
    }
}

class D extends B // B dziedziczy po A
{
    public function __construct()
    {
        parent::__construct(); // Wywoła konstruktor B, który (ponieważ nie ma własnego) wywoła konstruktor A
        echo "Konstruktor D<br>";
    }
}


echo "Tworzę obiekt B:<br>";
$objB = new B(); // Wywoła konstruktor A

echo "<hr>Tworzę obiekt C:<br>";
$objC = new C(); // Wywoła tylko konstruktor C (chyba że C jawnie wywoła parent::__construct())

echo "<hr>Tworzę obiekt D:<br>";
$objD = new D(); // Wywoła konstruktor A (przez B), potem D
?>

Zawsze dobrą praktyką jest jawne wywoływanie parent::__construct() w konstruktorze klasy potomnej, jeśli klasa bazowa ma konstruktor, który powinien być wykonany.

Podsumowanie Lekcji

W tej lekcji zgłębiliśmy mechanizm dziedziczenia w PHP. Nauczyliśmy się, jak używać słowa kluczowego extends do tworzenia klas potomnych, które dziedziczą publiczne i chronione składowe po klasach bazowych. Zrozumieliśmy, jak nadpisywać metody, aby dostosować zachowanie w klasach potomnych, oraz jak używać parent:: do odwoływania się do implementacji z klasy nadrzędnej, w szczególności do jej konstruktora.

Omówiliśmy również słowo kluczowe final, które pozwala na tworzenie metod finalnych (niemożliwych do nadpisania) oraz klas finalnych (niemożliwych do dziedziczenia), co daje większą kontrolę nad projektem hierarchii klas. Podkreśliliśmy znaczenie prawidłowego zarządzania konstruktorami w kontekście dziedziczenia.

Dziedziczenie jest potężnym narzędziem, które, gdy jest stosowane właściwie, prowadzi do bardziej zorganizowanego, elastycznego i reużywalnego kodu. W następnej lekcji przyjrzymy się klasom abstrakcyjnym i metodom abstrakcyjnym, które są ściśle związane z dziedziczeniem i pozwalają na definiowanie "szablonów" dla klas potomnych.