PHP/Dziedziczenie

Z Wikibooks, biblioteki wolnych podręczników.
< PHP
Przejdź do nawigacji Przejdź do wyszukiwania
Poprzedni rozdział: Konstruktory i destruktory
Spis treści
Następny rozdział: Interfejsy

Dziedziczenie klas[edytuj]

W naszych rozważaniach z początku rozdziału mówiliśmy o dziedziczeniu, które wyrażało nam, że "X jest Y-kiem". Dziedziczenie pozwala nam rozszerzyć już istniejącą klasę poprzez przejęcie jej pól oraz metod i dołożenie nowych. Jednak współdzielenie kodu to nie wszystko. Obiekty klasy dziedziczącej są jednocześnie obiektami wszystkich klas dziedziczonych, co oznacza, że możemy ich użyć tam, gdzie program spodziewa się dostać ogólniejszy obiekt.

Implementacja dziedziczenia[edytuj]

Przypuśćmy, że chcemy zbudować formularz WWW. W jego skład wchodzą różne elementy, lecz podstawowa zasada ich działania jest identyczna. Każdemu możemy ustawić nazwę i przypisać wartość. Skorzystamy z dziedziczenia, aby utworzyć klasę bazową Element zawierającą ogólny interfejs, a następnie stworzymy jej specjalizacje reprezentujące pole tekstowe, listę rozwijaną itd.

 1 <?php
 2 
 3 class FormElement
 4 {
 5    private $_name;
 6    private $_value;
 7 
 8    public function setName($name)
 9    {
10       $this->_name = $name;
11    } // end setName();
12 
13    public function getName()
14    {
15       return $this->_name;
16    } // end getName();
17    
18    public function setValue($value)
19    {
20       $this->_value = $value;
21    } // end setValue();
22 
23    public function getValue()
24    {
25       return $this->_value;
26    } // end getValue();
27 } // end FormElement;
28 
29 class FormInput extends FormElement
30 {
31    public function display()
32    {
33       echo '<input type="text" name="'.$this->getName().'" value="'.htmlspecialchars($this->getValue()).'" />';
34    } // end display();
35 } // end FormInput;
36 
37 class FormTextarea extends FormElement
38 {
39    private $_width = 60;
40    private $_height = 15;
41 
42    public function setDimensions($width, $height)
43    {
44       if($width < 1 || $height < 1)
45       {
46          return false;
47       }
48       $this->_width = $width;
49       $this->_height = $height;
50 
51       return true;
52    } // end setDimensions();
53 
54    public function display()
55    {
56       echo '<textarea name="'.$this->getName().'" rows="'.$this->_height.'" cols="'.$this->_width.'">'.htmlspecialchars($this->getValue()).'</textarea>';
57    } // end display();
58 } // end FormTextarea;

Aby wykonać dziedziczenie, po nazwie klasy dopisujemy słowo kluczowe extends i podajemy nazwę klasy, którą chcemy rozszerzyć. Dzięki temu zarówno FormInput, jak i FormTextarea mogą korzystać z metod getName() oraz getValue() mimo, iż nigdzie ich nie deklarowaliśmy. Ponadto dołożyły one własne metody umożliwiające wyświetlanie danego pola w określony sposób, a FormTextarea dołożył dodatkowo możliwość ustawiania rozmiarów pola tekstowego. Poniżej pokazany jest przykład wykorzystania naszych klas:

 1 <?php
 2 require('./FormElements.php');
 3 
 4 $fields = array();
 5 
 6 $field = new FormInput;
 7 $field->setName('nickname');
 8 $field->setValue('Wpisz tu swoją nazwę');
 9 
10 $fields[] = $field;
11 
12 $field = new FormTextarea;
13 $field->setName('comment');
14 $field->setDimensions(60, 5);
15 
16 $fields[] = $field;
17 
18 // Wyswietl formularz
19 foreach($fields as $field)
20 {
21    $field->display();
22 }

Kontrola dostępu w dziedziczeniu[edytuj]

Do tej pory poznaliśmy dwa modyfikatory dostępu: public oraz private. W naszym poprzednim przykładzie zauważyliśmy, że w metodzie display() odwoływaliśmy się do nazwy elementu poprzez getName(), zamiast odczytywać ją bezpośrednio z pola $_name. Wynika to z tego, że klasa pochodna (tj. FormInput, FormTextarea itd.) nie ma dostępu do prywatnych pól i metod klasy bazowej. Modyfikator private ogranicza nam dostęp do obiektów aktualnej i tylko aktualnej klasy, bez żadnych wyjątków. My tymczasem potrzebujemy czegoś pośredniego - zablokować dostęp z zewnątrz, a jednocześnie umożliwić go klasom potomnym. Dlatego wykorzystamy trzeci modyfikator, protected. Dzięki niemu możemy rozbudować naszą klasę FormElement o kilka przydatnych rzeczy.

Chronione elementy klasy są często wykorzystywane do tworzenia metod pomocniczych, które może wykorzystać programista rozszerzający klasę. U nas przydałaby się jakaś szybka możliwość tworzenia listy atrybutów dla znaczników formularzy. Wpisywanie ich na sztywno jest kiepskim pomysłem, ponieważ nie zawsze wszystkie atrybuty są potrzebne. Dlatego dodamy metodę, która przyjmie listę atrybutów jako tablicę i wyświetli tylko te niepuste, a następnie wykorzystamy ją w klasie potomnej.

 1 <?php
 2 
 3 class FormElement
 4 {
 5    protected $_name = null;
 6    protected $_value = null;
 7 
 8    public function setName($name)
 9    {
10       $this->_name = $name;
11    } // end setName();
12 
13    public function getName()
14    {
15       return $this->_name;
16    } // end getName();
17    
18    public function setValue($value)
19    {
20       $this->_value = $value;
21    } // end setValue();
22 
23    public function getValue()
24    {
25       return $this->_value;
26    } // end getName();
27 
28    protected function _buildAttributes(array $attributes)
29    {
30       $code = '';
31       foreach($attributes as $name => $value)
32       {
33          if($value !== null)
34          {
35             $code .= ' '.$name.'="'.htmlspecialchars($value).'"';
36          }
37       }
38       return $code;
39    } // end _buildAttributes();
40 } // end FormElement;
41 
42 class FormInput extends FormElement
43 {
44    public function display()
45    {
46       echo '<input'.$this->_buildAttributes(array(
47          'type' => 'text',
48          'name' => $this->getName(),
49          'value' => $this->getValue()
50       )).' />';
51    } // end display();
52 } // end FormInput;

W ramach ćwiczenia analogicznie zmodyfikuj klasę FormTextarea.

Stwórz obiekt klasy FormInput i ustaw mu nazwę, ale nie ustawiaj wartości. Wyświetl go i sprawdź źródło. Możemy zauważyć, że metoda pomocnicza _buildAttributes() pominęła nam atrybut value, gdyż jego wartość była pusta i nie było sensu go wyświetlać. Ponadto tym razem możemy już z poziomu naszych klas potomnych odwoływać się bezpośrednio do $_name oraz $_value, ponieważ zadeklarowaliśmy je jako pola chronione.

Unieważnianie metod[edytuj]

PHP pozwala na tworzenie w klasach potomnych pól oraz metod, które już istnieją w klasie bazowej. Działanie to nazywa się unieważnianiem, ponieważ nowa wersja metody zastępuje (unieważnia) dotychczasową i nie wymaga żadnej dodatkowej składni. Po prostu tworzymy nową metodę o identycznej nazwie i argumentach, jak istniejąca.

 1 <?php
 2 
 3 class FormCheckboxList extends FormElement
 4 {
 5    private $_options = array();
 6    protected $_value = array();
 7 
 8    public function setOptions(array $options)
 9    {
10       $this->_options = $options;
11       foreach($options as $name => $description)
12       {
13          $this->_value[$name] = false;
14       }
15    } // end setOptions(); 
16 
17    public function setValue($value)
18    {
19       if(!is_array($value))
20       {
21          return false;
22       }
23       foreach($value as $name => $checked)
24       {
25          if(isset($this->_options[$name]))
26          {
27             $this->_value[$name] = (boolean)$checked;
28          }
29       }
30       return true;
31    } // end setValue();
32 
33    public function display()
34    {
35       echo '<ul>';
36       foreach($this->_options as $name => $description)
37       {
38          echo '<li><input'.$this->_buildAttributes(array(
39             'type' => 'checkbox',
40             'name' => $this->_name.'['.$name.']',
41             'checked' => ($this->_value[$name] ? 'checked' : null)
42          )).' /> '.$description.'</li>';
43       }
44       echo '</ul>';
45    } // end display();
46 } // end FormCheckboxList;

Nasz nowy rodzaj elementów formularzy, FormCheckboxList, wyświetla listę checkbox-ów. Wartość elementu nie jest już pojedynczą liczbą czy tekstem, ale zbiorem wartości, który musi być odpowiednio przetworzony. Dlatego stworzyliśmy nową wersję metody setValue(), która upewnia się, że dostała tablicę, a później odpowiednio pakuje jej zawartość do wewnętrznych struktur obiektu. Zmieniliśmy także deklarację pola $_value tak, aby początkowo zawsze zawierało tablicę.

Przejrzystość wymaga, aby klasa FormElement dostała pustą metodę display(). Chcemy dzięki temu powiedzieć, że elementy formularzy mogą się wyświetlać, lecz nie precyzujemy jak. Dokładne zasady wyświetlania ustala sobie każdy rodzaj elementu z osobna. Utwórz pustą, publiczną metodę display() w klasie FormElement.

Przyjrzymy się teraz, jak podczas unieważniania zachowują się modyfikatory dostępu oraz argumenty.

Stosowanie się do tej zasady zapewni nam maksymalną zgodność ze standardami PHP. Poniższy przykład ilustruje poprawne konstrukcje:

 1 <?php
 2 
 3 class Foo
 4 {
 5 	public function metoda1($foo)
 6 	{
 7 		echo $foo;
 8 	} // end metoda1();
 9 
10 	public function metoda2($foo, $bar = '')
11 	{
12 		echo $foo;
13 	} // end metoda2();
14 
15 	public function metoda3($foo)
16 	{
17 		echo $foo;
18 	} // end metoda3();
19 } // end Foo;
20 
21 class Bar extends Foo
22 {
23 	protected $_bar = array();
24 
25 	public function metoda1($foo)
26 	{
27 		echo 'Nowe wywołanie';
28 	} // end metoda1();
29 
30 	public function metoda2($foo, $bar = 'Nowa wartość domyślna')
31 	{
32 		echo 'Nowe wywołanie';
33 	} // end metoda2();
34 
35 	public function metoda3($foo, $bar = 'Nowy argument opcjonalny')
36 	{
37 		echo 'Nowe wywołanie';
38 	} // end metoda3();
39 } // end Bar;

Zobaczmy teraz, co się stanie, gdy złamiemy jedną z tych reguł. Sprawmy, by nowy argument w metodzie metoda3() był wymagany (tj. usuwamy domyślną wartość):

35 public function metoda3($foo, $bar)

Jeżeli nie grzebaliśmy nic przy ustawieniach raportowania błędów, które zostały zaproponowane na początku podręcznika, dostaniemy niemiły komunikat:

Strict Standards: Declaration of Bar::metoda3() should be compatible with that of Foo::metoda3() in /sciezka/do/pliku.php on line 35

Błędy Strict Standards to upomnienia, że naruszyliśmy jakąś regułę. Mimo iż skrypt pozornie działa dalej, nigdy nie należy ich ignorować, ponieważ ich łamanie może spowodować, że nasz skrypt przestanie działać na przyszłych wersjach PHP lub że jego wykonywanie może prowadzić do błędów w innym miejscu. Zauważmy: obiekty Bar są jednocześnie obiektami klasy Foo. Jeżeli w pewnym miejscu skrypt oczekuje obiektów Foo, ma prawo zakładać, że metoda3() posiada jeden wymagany argument i tak też ją wywoła. Tymczasem my beztrosko wprowadzamy mu obiekt klasy Bar, który teoretycznie powinien tu zadziałać, lecz powoduje nam niespodziewany błąd, gdyż tutaj metoda3() ma już dwa wymagane argumenty. To jest cena naszej ignorancji.

Modyfikatory dostępu mogą być zmieniane w ograniczonym zakresie. Możemy osłabiać dostęp (np. zastąpić metodę prywatną chronioną oraz chronioną przez publiczną), ale nie możemy czynić go bardziej restrykcyjnym. Jeśli w klasie bazowej metoda zadeklarowana jest jako chroniona, próba zastąpienia jej metodą prywatną skończy się natychmiastowym błędem krytycznym.

Unieważniając metody, mamy dostęp do jeszcze jednej przydatnej możliwości. Przypuśćmy, że chcemy jedynie rozszerzyć istniejącą funkcjonalność, a nie całkowicie ją zastępować. Na szczęście PHP pozwala na wywołanie pierwotnej wersji metody:

1 public function metoda($argument)
2 {
3    echo 'Trochę dodatkowych operacji';
4    parent::metoda($argument);
5 } // end metoda();

Konstruktory i destruktory w dziedziczeniu[edytuj]

Konstruktory oraz destruktory zachowują się prawie identycznie, jak zwykłe metody. Gdy klasa potomna nie będzie zawierać konstruktora albo destruktora, PHP po prostu odziedziczy go po klasie bazowej. Jednak jeśli zdecydujemy się go unieważnić, nie wykona się on, dopóki tego nie powiemy explicite poprzez znaną już nam konstrukcję parent::metoda(). Jedyna różnica polega na tym, że nie ma ograniczeń co do zmiany ilości argumentów w konstruktorach klas potomnych. Jest tak, ponieważ konstruktor jest wywoływany automatycznie tylko podczas tworzenia obiektu konkretnej klasy, do której należy.

Dodajmy konstruktor do klasy FormElement tak, aby można było natychmiast ustawić nazwę:

 1 <?php
 2 
 3 class FormElement
 4 {
 5    protected $_name;
 6    protected $_value;
 7 
 8    public function __construct($name)
 9    {
10       $this->_name = $name;
11    } // end __construct();
12 
13    // dalsza część klasy
14 } // end FormElement;

To wystarczy, aby przy tworzeniu wszystkich elementów trzeba było określić ich nazwę. Klasy potomne odziedziczą ten konstruktor i wykorzystają go u siebie. Jednak gdy zdecydujemy się wprowadzić nowy konstruktor, musimy jawnie powiedzieć, że chcemy wywołać także stary:

 1 <?php
 2 
 3 class FormCheckboxList extends FormElement
 4 {
 5    private $_options = array();
 6    protected $_value = array();
 7 
 8    public function __construct($name, array $options)
 9    {
10       parent::__construct($name);
11       $this->setOptions($options);
12    } // end __construct();
13 
14    // dalsza część klasy
15 } // end FormCheckboxList;

Jak widać w konstruktorze dodaliśmy nowy argument wymagany.

Aby uczynić klasę bardziej elastyczną, możemy dodać wartosć domyślną do argumentu konstruktora:

 1 <?php
 2 
 3 class FormElement
 4 {
 5    protected $_name;
 6    protected $_value;
 7 
 8    public function __construct($name = null)
 9    {
10       $this->_name = $name;
11    } // end __construct();
12 
13    // dalsza część klasy
14 } // end FormElement;

Dzięki temu określenie nazwy elementu bezpośrednio podczas tworzenia obiektu jest możliwe, ale nie jest już wymagane. Analogicznie możesz zmodyfikować klasę FormCheckboxList

Klasy abstrakcyjne[edytuj]

W naszej rzeczywistości nie wszystkie pojęcia muszą mieć praktyczne zastosowanie. Niektóre pozwalają po prostu wygodnie odnosić się do grupy wielu różnych rzeczy. W historyjce z początku rozdziału mówiliśmy o towarach: chlebie, napojach, warzywach itd., ale nigdzie nie pojawił się towar, który był tylko towarem i niczym więcej. Dlatego powiemy, że towar jest pojęciem abstrakcyjnym. Nie może występować samodzielnie, ale może pomagać określać inne pojęcia. W świecie programowania obiektowego towar byłby tzw. klasą abstrakcyjną. Jest to specjalny rodzaj klasy stworzony specjalnie po to, aby po nim dziedziczyć. Tworzenie obiektów klas abstrakcyjnych jest zabronione, za to można tworzyć obiekty ich klas potomnych.

Klasę abstrakcyjną deklaruje się, dodając przed słowem class dodatkowy modyfikator abstract. Ponownie przyjrzyjmy się naszemu systemowi wyświetlania formularzy. Takim abstrakcyjnym bytem jest tam FormElement. Sam w sobie nie nadaje się do niczego, ponieważ nie ma zdefiniowanego wyświetlania, za to stanowi podbudowę dla innych klas. Przepiszmy tę klasę po raz kolejny:

 1 <?php
 2 
 3 abstract class FormElement
 4 {
 5    protected $_name = null;
 6    protected $_value = null;
 7 
 8    public function __construct($name)
 9    {
10       $this->_name = $name;
11    } // end __construct();
12 
13    public function setName($name)
14    {
15       $this->_name = $name;
16    } // end setName();
17 
18    public function getName()
19    {
20       return $this->_name;
21    } // end getName();
22    
23    public function setValue($value)
24    {
25       $this->_value = $value;
26    } // end setName();
27 
28    public function getValue()
29    {
30       return $this->_value;
31    } // end getName();
32 
33    abstract public function display();
34 
35    protected function _buildAttributes(array $attributes)
36    {
37       $code = '';
38       foreach($attributes as $name => $value)
39       {
40          if($value !== null)
41          {
42             $code .= ' '.$name.'="'.htmlspecialchars($value).'"';
43          }
44       }
45       return $code;
46    } // end _buildAttributes();
47 } // end FormElement;

Teraz próba napisania new FormElement('nazwa') zakończy się błędem wykonania skryptu.

W podanym kodzie możemy zauważyć jeszcze jedną rzecz, a mianowicie metodę abstrakcyjną. Analogicznie jak w przypadku klasy, jest to metoda, która jest przeznaczona do tego, aby ją unieważnić, dlatego też nie może zawierać żadnej treści. Po nawiasach zamykających listę argumentów możemy postawić już jedynie średnik. Idealnie nadaje się to dla naszej metody display(). Chcemy powiedzieć, że elementy mogą być wyświetlane, ale szczegóły pozostawiamy do zaimplementowania klasom potomnym.

Definicja ta mówi nam jeszcze jedno. Przypuśćmy, że stworzyliśmy klasę dziedziczącą po FormElement, która nie zaimplementowała metody display(). Dopóki jej nie dodamy, nowa klasa także musi być zadeklarowana jako abstrakcyjna!

Do koncepcji abstrakcji będziemy często wracać w następnych rozdziałach.

Słowo "final"[edytuj]

Słowo abstract wymusza na programiście konieczność dziedziczenia po klasie oraz unieważnienia metody. W PHP istnieje także jego odwrotność, czyli słowo final, która uniemożliwia takie działanie. Jedyna różnica polega na tym, że klasa posiadająca metody finalne, nie musi być deklarowana jako finalna.

Metody finalne należy stosować tam, gdzie obecność jakiegoś algorytmu w takiej postaci, w jakiej go napisaliśmy, jest krytyczna dla działania całości, a próba jego unieważnienia mogłaby się dla skryptu skończyć tragicznie.

Obiekt potomka jest obiektem klasy bazowej[edytuj]

Przyjrzyjmy się teraz praktycznej obserwacji dotyczącej dziedziczenia. Do tej pory używaliśmy go wyłącznie jako wygodny sposób na współdzielenie kodu, jednak mechanizm ten sięga o wiele głębiej. Napiszmy klasę zarządcy dla naszego formularza:

 1 <?php
 2 
 3 class FormBuilder
 4 {
 5    protected $_elements = array();
 6 
 7    final public function addElement(FormElement $element)
 8    {
 9       $this->_elements[] = $element;
10       return $element;
11    } // end addElement();
12 
13    public function display()
14    {
15       foreach($this->_elements as $element)
16       {
17          $element->display();
18       }
19    } // end display();
20 } // end FormBuilder;

Metoda addElement() została zadeklarowana jako finalna, ponieważ nie przewidujemy możliwości zmiany sposobu dodawania nowych elementów do formularza. Programista może rozszerzyć tę klasę, by np. udoskonalić wyświetlanie, ale proces dodawania nowych elementów ma zostawić w spokoju. Zwróćmy także uwagę na argument, który musi być obiektem klasy FormElement. Spójrzmy teraz, jak używać nowej klasy:

 1 <?php
 2 
 3 require('./FormElements.php');
 4 require('./FormBuilder.php');
 5 
 6 $form = new FormBuilder;
 7 $form->addElement(new FormInput('name'));
 8 $form->addElement(new FormInput('email'));
 9 $form->addElement(new FormTextarea('comment'))->setDimensions(70, 15);
10 
11 $form->display();

Ukazuje on praktyczne znaczenie dziedziczenia. Choć tworzymy obiekty klasy FormInput, możemy je przekazać jako argument FormElement, ponieważ dziedziczenie mówi nam jasno: FormInput używa interfejsu z FormElement, posiada wszystkie jego zachowania oraz właściwości, dlatego obiekt FormInput jest jednocześnie obiektem FormElement. Przy okazji spójrzmy na następującą linijkę:

9 $form->addElement(new FormTextarea('comment'))->setDimensions(70, 15);

Jest to ilustracja, że referencja do obiektu wcale nie musi być przechowywana w zmiennej. Jeżeli jakaś funkcja lub metoda zwraca obiekt, możemy tuż po niej napisać -> i dostać się do jego elementów bez potrzeby stosowania zmiennej tymczasowej. Zastosowaliśmy tu pewną sztuczkę: metoda addElement() po prostu zwraca element przekazany jako argument po to, aby nie trzeba było przepisać obiektu do zmiennej, gdy chcemy ustawić jeszcze jakieś dodatkowe właściwości. Możemy to rozbudować jeszcze dalej i sprawić, że metody takie, jak setValue() czy setDimensions() będą po prostu zwracać $this, dzięki czemu taki łańcuszek wywołań metod można ciągnąć w nieskończoność. Technika ta nosi nazwę fluent interface i spotkamy się z nią jeszcze w dalszej części podręcznika.

Ćwiczenie[edytuj]

Aby przećwiczyć poznane wiadomości, wróćmy do przykładu z systemem konfiguracji. Nadaje się on idealnie do dalszej rozbudowy poprzez dziedziczenie. Zauważmy, że konfiguracji nie musimy ładować wyłącznie z plików INI. Zamiast tego, możemy utworzyć abstrakcyjną klasę ConfigLoader definiującą interfejs ładowania konfiguracji, która następnie będzie rozszerzana przez rozmaite specjalizacje, np. IniFileConfigLoader, PhpConfigLoader itd. Twoim zadaniem jest odpowiednia przebudowa tamtego kodu. Zdefiniuj interfejs klasy abstrakcyjnej ConfigLoader. Określ, które metody muszą być abstrakcyjne, a które finalne oraz gdzie zastosować słowo protected. Dodaj niezbędne konstruktory i destruktory oraz interfejs fluent interface do głównej klasy. W IniFileConfigLoader dodaj możliwość wyłączenia sprawdzania, czy plik konfiguracyjny istnieje. Przetestuj swoje modyfikacje na podanym przykładzie:

1 <?php
2 
3 $config = new Config;
4 
5 $config->addLoader(new IniFileConfigLoader('./basic.ini'))->setFileExistsCheck(true);
6 $config->addLoader(new PhpConfigLoader('./extra.php'));
7 
8 echo $config->get('basic_option');
9 echo $config->get('php_option');

Zakończenie[edytuj]

Po poznaniu dziedziczenia potrafimy już całkiem sporo wyrazić przy pomocy obiektów. Dziedziczenie ma jednak pewne ograniczenie: nie można dziedziczyć po dwóch klasach naraz:

1 <?php
2 
3 class Klasa extends A, B
4 {
5    // ...
6 } // end Klasa;

W następnym rozdziale poznamy mechanizm pozwalający częściowo poradzić sobie z tym problemem, czyli interfejsy.