Programowanie obiektowe w PHP 5 cz. 2

Autor: Tomasz Jędrzejewski
Data publikacji: 02.01.2005, 16:55 | Ostatnia modyfikacja: 19.11.2006, 17:36

Druga część artykułu poświęcona programowaniu obiektowemu w PHP 5. Autor opisuje dziedziczenie, statyczne elementy klasy oraz oraz klonowanie obiektów.

Spis treści

Witam w drugiej części artykułu poświęconego programowaniu obiektowemu (OOP) w PHP 5. Zajmiemy się w niej klonowaniem obiektów, statycznymi elementami klasy oraz rozszerzaniem możliwości już istniejących klas, czyli dziedziczeniem.

Statyczne elementy klasy

Aby używać możliwości danej klasy, wcale nie musimy tworzyć jej obiektu. Jeśli zadeklarujemy dane pole bądź metodę jako statyczną, otrzymamy w praktyce zwyczajną zmienną lub funkcję, tyle że powiązaną z jakąś klasą. Oto przykład:

<?php
 
   class zestaw{
      static $format_daty;
 
      static function inicjuj_zestaw($format_daty){
         self::$format_daty = $format_daty;
      } // end inicjuj_zestaw();
 
      static function data($czas = 0){
         if($czas == 0){
            return date(self::$format_daty);
         }
         return date(self::$format_daty, $czas);
      } // end data();
 
      static function data_strefowa($strefa, $czas = 0){
         if($czas == 0){
            return gmdate(self::$format_daty, time() + (3600 * $strefa));
         }
         return date(self::$format_daty, $czas + (3600 * $strefa));
      } // end data_strefowa();
   }
 
   zestaw::inicjuj_zestaw('d.m.Y H:i');
 
   echo 'Data w twojej strefie czasowej: '.zestaw::data().'<br/>';
   echo 'Data na Grenlandii: '.zestaw::data_strefowa(-3).'<br/>';
?>

W przykładzie chcieliśmy mieć parę funkcji do obsługi daty i czasu. Zapakowaliśmy je w klasę, ale jako że obiektu nam do tego raczej nie potrzeba, wszystkie jej elementy zadeklarowaliśmy jako statyczne słowem kluczowym static. Dzięki temu możemy do nich odwoływać się, nie tworząc obiektu. Oczywiście robimy to trochę inaczej, gdyż najpierw podajemy nazwę klasy, a następnie operatorem '::' oddzielamy ją od nazwy statycznej metody/pola. Dodam, iż w tym przypadku nazwa pola musi być rozpoczęta znakiem dolara (klasa::$pole).

Z wnętrza metod statycznych możemy odwoływać się do innych statycznych pól i metod poprzez specjalny "wskaźnik", self, wskazujący zawsze na aktualną klasę. Widać to z resztą na przykładzie.

Co jeszcze powinieneś wiedzieć o elementach statycznych? Ano że można je mieszać z elementami niestatycznymi.

Jako ciekawostkę dodam, iż używanie elementów statycznych jest odrobinę wolniejsze od tworzenia i korzystania z normalnych obiektów, dlatego najlepiej stosować taką taktykę w niewielkich skryptach. W większych różnica w prędkości jest coraz wyraźniej odczuwalna.

Do góry

Klonowanie obiektów

W poprzedniej części wspomniałem, iż normalny operator przypisania nie tworzy kopii istniejącego obiektu, a jedynie nowy odnośnik do niego. Jednak co będzie, gdy naprawdę będziemy musieli utworzyć kopię jakiegoś obiektu? Jak to wykonać? Jest na to sposób - operator clone. Posłużymy się tutaj jednym z przykładów z poprzedniej części artykułu.

<?php
 
   class osoba{
      public $imie;
      public $nazwisko;
      public $ksywa;
   }
 
   $ja = new osoba;
   $ja -> imie = 'Tomasz';
   $ja -> nazwisko = 'Jedrzejewski';
   $ja -> ksywa = 'Zyx';
 
   echo 'JA: '.$ja -> imie.' '.$ja -> nazwisko.' aka. '.$ja -> ksywa.'<br/>';
 
   $on = clone $ja; // 1
 
   $on -> imie = 'Bartosz';
   $on -> nazwisko = 'Maciaszek';
   $on -> ksywa = 'Sickboy';
 
   echo 'ON: '.$on -> imie.' '.$on -> nazwisko.' aka. '.$on -> ksywa.'<br/>';
   echo 'JA: '.$ja -> imie.' '.$ja -> nazwisko.' aka. '.$ja -> ksywa.'<br/>';
?>

Tym razem zmienna $on wskazywała już na kopię obiektu, a nie na obiekt oryginalny. Stąd też po zmianie danych poprzez $on, obiekt $ja zachował swoje pierwotne wartości. W końcu jest oddzielnym obiektem. Przyjrzyj się dobrze operatorowi klonowania (1). Musisz o nim wiedzieć to, iż on sam nie robi przypisania, lecz generuje nowy obiekt na podstawie już istniejącego. Stąd też, aby zapisać gdzieś kopię, koniecznie należy połączyć go z operatorem =.

No dobrze, a co będzie, kiedy każdy obiekt danego typu będzie w jednym z pól trzymał dane specyficzne dla siebie? Gdybyśmy zrobili wszystko tak, jak w powyższym przykładzie, wartość tego pola zostałaby skopiowana również i dwa obiekty miałyby w nim te same dane, co powodowałoby problemy. Z pomocą przychodzi nam tu metoda specjalna - __clone(). Nie pobiera ona żadnych parametrów, nie zwraca wartości.

<?php
 
   class plik{
      private $nazwa;
      private $tryb;
      private $f;
 
      public function __construct($nazwa, $tryb){
         $this -> nazwa = $nazwa;
         $this -> tryb = $tryb;
         $this -> f = fopen($nazwa, $tryb);
      } // end __construct();
 
      public function czytaj($bajtow = 0){
         if($bajtow == 0){
            return fread($this->f, filesize($this->nazwa));
         }
         return fread($this -> f, $bajtow);
      } // end czytaj();
 
      public function __destruct(){
         fclose($this -> f);
      } // end __destruct();
 
      public function __clone(){
         $this -> f = fopen($this -> nazwa, $this -> tryb);
      } // end __clone();
 
   }
 
   echo '<pre>';
   $p1 = new plik('test.txt', 'r');
   echo 'P1: '.$p1 -> czytaj(35);
 
   $p2 = clone $p1;
   echo 'P2: '.$p2 -> czytaj(35);
?>

Mamy tu klasę do obsługi plików. Każdy jej obiekt powinien mieć własne połączenie z danym plikiem. Dlatego też w metodzie clone() ręcznie tworzymy nowe połączenie. Nie uświadczymy w niej jednak kodu kopiującego pozostałe właściwości z obiektu $p1 do $p2. Dlaczego? Otóż zostały one skopiowane przed wywołaniem tej metody, gdyż ta ma za zadanie już tylko pozmieniać wartości tych pól, które zmiany wymagają. Stąd brak kopiowania pozostałych pól.

Po czym poznać, iż metoda clone() została wywołana? To proste. Na ekranie dwa razy pokaże nam się początek pliku, nie zaś początek i dalsza część (którą otrzymalibyśmy, gdyby dwa obiekty korzystały z tego samego połączenia do niego).

Teraz, kiedy wyjaśniliśmy sobie już sprawę kopiowania istniejących obiektów, przejdźmy do dziedziczenia, czyli rozszerzania już istniejących klas.

Do góry

Dziedziczenie

Naturalną dla człowieka rzeczą jest klasyfikowanie rzeczy według różnych kategorii. W świecie zwierząt od dłuższego czasu używa się wielostopniowego podziału na królestwa, gatunki, rasy i inne takie duperszmity. W innych dziedzinach kategorie wykorzystywane są do klasyfikacji treści, do porządkowania, wreszcie do przerzucania części zadań na wspólne dwóm urządzeniom podzespoły. Naturalnie wszystko to zawarte zostało w programowaniu obiektowym. Kiedy stworzymy klasę, nie będziemy wcale ograniczeni do jej "wbudowanej" funkcjonalności. Jeśli potrzebne nam będzie 10 podobnych klas, tyle że operujących na innych zbiorach danych, wcale nie będziemy musieli wszystkiego pisać od nowa dla każdej z nich. Dzięki mechanizmowi dziedziczenia wspólne metody, pola możemy przerzucić do klasy-matki, a w klasach potomnych nadpisać tylko to, co potrzebne. Co to nam da? Oszczędzimy czas, zmniejszymy i przyspieszymy kod, łatwiej będzie nam poprawić znalezione w nim błędy - jeżeli jakiś zagnieździ się we wspólnym kawałku kodu, naprawimy go w jednej klasie-matce i zmiany będą uwzględnione we wszystkich klasach potomnych. To jest dziedziczenie - rozszerzanie już istniejących klas i tworzenie hierarchii oraz zależności pomiędzy nimi.

Jak działa dziedziczenie? Otóż gdy mamy dwie klasy i w jednej z nich dopiszemy po jej nazwie extends klasa_pierwsza, wtedy do jej zestawu metod i pól dodawany jest podobny zestaw z klasy rozszerzanej. Możesz to obejrzeć na poniższym schemacie:

W praktyce wygląda to tak:

<?php
 
   class osoba{
      public $imie;
      public $nazwisko;
 
      public function nazwa(){
         return $this -> imie.' '.$this -> nazwisko;
      } // end nazwa();
   }
 
   class pracownik extends osoba{
      public $zarobki;
 
      public function podwyzka($kwota){
         $this -> zarobki += $kwota;
      } // end podwyzka();
   }
 
   class student extends osoba{
      private $ocen;
      private $suma_ocen;
 
      public function srednia(){
         return round($this -> suma_ocen / $this -> ocen, 2);
      } // end srednia();
 
      public function dodaj_ocene($ocena){
         $this -> ocen++;
         $this -> suma_ocen += $ocena;
      } // end dodaj_ocene();
   }
 
   $osoba = new osoba;
   $pracownik = new pracownik;
   $student = new student;
 
   $osoba -> imie = 'Jan';
   $osoba -> nazwisko = 'Kowalski';
 
   $pracownik -> imie = 'Piotr';
   $pracownik -> nazwisko = 'Nowak';
   $pracownik -> zarobki = 2000;
 
   $student -> imie = 'Adam';
   $student -> nazwisko = 'Adamowski';
   $student -> dodaj_ocene(5);
   $student -> dodaj_ocene(4);
   $student -> dodaj_ocene(5);
 
   echo 'OSOBA: '.$osoba -> nazwa().'<br/>';
   echo 'Student '.$student -> nazwa().' (średnia '.$student->srednia().')<br/>';
   echo 'Pracownik '.$pracownik -> nazwa().' (zarobki - '.$pracownik->zarobki.' zl)<br/>';
 
   $student -> dodaj_ocene(3);
   $pracownik -> podwyzka(115);
 
   echo 'Student '.$student -> nazwa().' (średnia '.$student->srednia().')<br/>';
   echo 'Pracownik '.$pracownik -> nazwa().' (zarobki - '.$pracownik->zarobki.' zl)<br/>';
?>

Mamy tutaj dwie klasy, które dziedziczą do siebie właściwości trzeciej klasy - osoba. Jak widać na przykładzie, odziedziczone pola oraz metodę nazwa() możemy używać tak, jakby była ona zadeklarowana w tych dwóch klasach. Zatem dziedziczenie nie jest widoczne dla nas, programistów. Nie musimy stosować żadnej specjalnej składni, aby dostać się do tamtych elementów.

Zauważ, iż dziedziczenie zachodzi tylko w jedną stronę - w klasie bazowej osoba nie możemy używać elementów klas student oraz pracownik.

Do góry

Metody, a dziedziczenie

Osobnego omówienia wymaga dziedziczenie metod, gdyż tutaj mogą wystąpić różne dziwne "komplikacje". Przede wszystkim - co, jeśli chcemy do istniejącej metody dodać w klasie pochodnej jeszcze jakiś kod? Stworzyć drugą? Nie - możemy stworzyć metodę nazywającą się tak samo. Wtedy nadpisze ona tę samą metodę z klasy pochodnej, dając jednak możliwość wewnętrznego odwołania się do "rodzica".

<?php
 
   class osoba{
      private $imie;
      private $nazwisko;
 
      public function __construct($imie, $nazwisko){
         $this -> imie = $imie;
         $this -> nazwisko = $nazwisko;
      } // end __construct();
 
      public function nazwa(){
         return $this->imie.' '.$this->nazwisko;
      } // end nazwa();
 
      public function powitanie(){
         return 'Dzien dobry';
      } // powitanie();
   }
 
   class raper extends osoba{
      private $ksywa;
 
      public function __construct($imie, $nazwisko, $ksywa){
         parent::__construct($imie, $nazwisko);
         $this -> ksywa = $ksywa;
      } // end __construct();
 
      public function nazwa(){
         return parent::nazwa().' (aka '.$this->ksywa.')';
      } // end nazwa();
 
      public function powitanie(){
         return 'Joł, ziomalu!';
      } // end powitanie();
   }
 
   $osoba = new osoba('Jan', 'Kowalski');
   // ewentualna zbieznosc ksywy ewentualnie przypadkowa
   $raper = new raper('Adam', 'Adamski', 'kOOkOOs');
 
   echo $osoba -> nazwa().' mowi '.$osoba -> powitanie().'<br/>';
   echo $raper -> nazwa().' mowi '.$raper -> powitanie().'<br/>';
?>

Efekt działania:

Jan Kowalski mowi Dzien dobry
Adam Adamski (aka kOOkOOs) mowi Joł, ziomalu!

Co my tu widzimy? Ano że w klasie raper nadpisujemy wszystkie trzy metody z klasy bazowej osoba. Jednak w dwóch pierwszych korzystamy z odziedziczonego dorobku poprzez statyczny wskaźnik parent dostępny jedynie w klasach, które dziedziczą. Użyliśmy go do wywołania konstruktora oraz metody nazwa() z klasy bazowej, gdyż chcemy tylko rozszerzyć ich funkcjonalność, a nie pisać je od nowa. W dodatku w klasie osoba wszystkie pola są zadeklarowane jako prywatne, zatem raper ich nie widzi - użycie pierwotnych wersji metod jest więc niezbędne. Ale już metoda powitanie() jest nadpisywana tak, by robiła coś zupełnie innego (wszak raperzy raczej "Dzień dobry" nie mówią :)).

Przyjrzyjmy się wywołaniu np. konstruktora klasy raper - wprowadzamy do niego trzy dane: imię, nazwisko oraz ksywę rapera. Dwie pierwsze przekazywane są do ręcznie odpalanego konstruktora klasy osoba, by ten wprowadził je do pól obiektu. Trzecią obsługuje już konstruktor pochodny. W ten sposób rozszerzyliśmy funkcjonalność metody __construct() o dodatkowy kod.

Co należy zapamiętać z tego rozdziału? Ano, że jeśli chcemy jakąkolwiek metodę rozszerzyć, a nie nadpisać (dotyczy to również konstruktorów, destruktorów i wszystkich innych metod specjalnych), musimy ręcznie wywołać jej starą wersję z klasy bazowej poprzez statyczny "wskaźnik" parent.

Do góry

Słowa kluczowe

Przy poprzedniej lekcji wspomniałem, iż pola i metody zadeklarowane jako prywatne w klasie bazowej, nie są widoczne ani w jej obiektach, ani w klasie pochodnej. Co jednak, gdy w niej muszą się one znajdować? Z pomocą przychodzi tutaj deklaracja ich jako elementy chronione słowem kluczowym protected. Wtedy co prawda dalej nie będzie można się do nich dostać zewnętrznie, ale przynajmniej będą one widoczne i dostępne dla klas pochodnych. Właściwość ta przydaje się w poniższym przykładzie, gdzie mamy klasę obsługującą czytanie z pliku. Aby można było ją łatwo rozszerzać, udostępniono w niej pola $polaczenie i $nazwa identyfikujące kolejno: połączenie i nazwę otwartego pliku, właśnie jako chronione. Nie ma obawy, że jakiś nieuważny programista używający naszych klas coś popsuje, ma natomiast możliwość popsucia czegoś przy próbie rozszerzenia ich funkcjonalności :).

<?php
 
   class plik{
      protected $polaczenie;
      protected $nazwa;
 
      public function __construct($plik){
         if(file_exists($plik)){
            $this -> polaczenie = fopen($plik, 'r');
         }
         $this -> nazwa = $plik;
      } // end __construct();
 
      public function __destruct(){
         if(is_resource($this->polaczenie)){
            fclose($this -> polaczenie);
         }
      } // end __destruct();
 
      public function __toString(){
         return $this -> nazwa;
      } // end __toString();
 
      public function sukces(){
         if(is_resource($this -> polaczenie)){
            return 1;
         }
         return 0;
      } // end sukces();
 
      public function czytaj($bajtow){
         if(!feof($this -> polaczenie)){
            return fread($this->polaczenie, $bajtow);         
         }
      } // end czytaj();   
   }
 
   class plik_ex extends plik{
 
      public function __construct($plik, $typ){
         if($typ == 0){
            parent::__construct($plik);
         }else{
            if(file_exists($plik)){
               $this -> polaczenie = fopen($plik, 'w');
            }
            $this -> nazwa = $plik;
         }
      } // end __construct();
 
      public function ustaw_tryb($tryb){
         if(is_resource($this->polaczenie)){
            fclose($this -> polaczenie);
         }
         if($tryb == 0){
            $this -> polaczenie = fopen($this->nazwa, 'r');
         }else{
            $this -> polaczenie = fopen($this->nazwa, 'w');
         }
      } // end ustaw_tryb();
 
      public function zapisz($dane){
         fwrite($this -> polaczenie, $dane);
      } // end zapisz();
   }
 
   // Plik podstawowy - mozemy tylko czytac
   $plik = new plik('test.txt');
   if($plik -> sukces()){
      echo $plik -> czytaj(50).'<br/>';
   }
 
   unset($plik);
 
   // Plik rozszerzony - mozemy zarowno zapisywac
   $plik = new plik_ex('test.txt', 1);
   if($plik -> sukces()){
      $plik -> zapisz('Ala ma kota, a kot ma AIDS');
   }
   // ... jak i czytac, przy uzyciu metod odziedziczonych po klasie "plik"
   $plik -> ustaw_tryb(0);
 
   if($plik -> sukces()){
      echo $plik -> czytaj(50).'<br/>';
   }
   echo 'A plik nazywa się ',$plik,'<br/>';
?>

Możesz spróbować "włamania" do obiektu lub zmiany typu pól zadeklarowanych w klasie plik na prywatne - w obu tych przypadkach skrypt przestanie funkcjonować. Dodam, iż w ten sam sposób możemy "ubezpieczać" metody - w ich deklaracji po prostu piszemy słowo protected zamiast public, czy innego.

W powyższym kodzie pojawiła nam się ponadto tajemnicza metoda specjalna - __toString(). Jest ona wywoływana przez PHP, gdy gdy próbujemy użyć naszej zmiennej obiektowej jako ciągu tekstowego, a co za tym idzie, pozwala na konwersję obiektów do tekstów :). Użyłem jej tu do pobierania nazwy obsługiwanego pliku. Dzięki temu wystarczy, że napiszemy echo $plik;, a otrzymamy jego nazwę i nie musimy kombinować z echo $plik -> nazwa (tak nam z resztą PHP nie pozwoli) lub echo $plik -> pobierz_nazwe();.

Do omówienia pozostało nam jeszcze słowo kluczowe final. Jego zadanie jest zależne od tego, gdzie go użyjemy. I tak:

Na klasie - uniemożliwia rozszerzenie danej klasy.
Na metodzie - odwrotność słowa protected; metoda dostępna z zewnątrz, lecz nie można jej nadpisać.
Na polu - generuje komunikat błędu :).

Spróbuj uruchomić poniższy przykład, a zobaczysz, że PHP rzeczywiście blokuje nas przed "niedozwolonymi" działaniami.

<?php
 
   final class xxx{
 
   }
 
   class yyy extends xxx{
 
   }
 
   class ppp{
 
      final function para(){
         echo 'tetete';
      } // end para();
   }
 
   class śśś extends ppp{
      public function para(){
         echo 'para';
      }
   }
?>

Właściwość ta jest przydatna przy pisaniu jakiejś biblioteki ogólnego użytku, gdyż możemy w ten sposób zabezpieczyć się przed zbyt ciekawskimi programistami :).

Do góry

Klasy abstrakcyjne

Programowanie obiektowe przewiduje możliwość tworzenia klas przeznaczonych wyłącznie do rozszerzenia, od których nie można utworzyć obiektów. Nazywamy je klasami abstrakcyjnymi. Abstrakcyjna może być zarówno cała klasa, jak i jej część (wybrane metody, które muszą zostać nadpisane w klasie pochodnej). Przydaje się to np. przy tworzeniu elementów wyjściowych dla różnych klas robiących wprawdzie to samo, ale na różnych zasobach danych. Tutaj zostanie to przedstawione na przykładzie skryptu do kontroli danych z formularzy/URL'i, nazwanego dla naszych potrzeb "maperem". Zasada jego działania jest prosta. Ustawiamy kolejnym polom flagi opisujące, jak ma wyglądać ich zawartość. Jeżeli wszystko będzie się zgadzać, zostaną utworzone od nich referencje, dając nam możliwość korzystania z nich.

<?php
 
   define('NREQUIRED', 0);
   define('REQUIRED', 1);
 
   abstract class mapper{
      protected $mapped_data;
      public $mapping_ok = 1;
 
      public function __get($name){
         if(isset($this->mapped_data[$name])){
            return $this->mapped_data[$name];
         }
         return NULL;
      } // end __get();
 
      abstract function add_mapping($name, $type);
 
   }
 
   class url_mapper extends mapper{
 
      public function add_mapping($name, $type){
         if($type == REQUIRED){
            if(strlen(trim($_GET[$name])) == 0){
               return ($this -> mapping_ok = 0);
            }else{
               $this -> mapped_data[$name] = &$_GET[$name];
               $this -> mapping_ok = $this -> mapping_ok && 1;
               return 1;
            }
         }else{
            if(strlen(trim($_GET[$name])) == 0){
               $this -> mapped_data[$name] = NULL;
            }else{
               $this -> mapped_data[$name] = &$_GET[$name];
            }
            return 1;
         }
         return 0;
      } // end add_mapping();
   }
 
   $mapper = new url_mapper();
   $mapper -> add_mapping('par1', REQUIRED);
   $mapper -> add_mapping('par2', NREQUIRED);
 
   if($mapper -> mapping_ok){
      echo 'Par1: '.$mapper -> par1.'<br/>';
      if($mapper -> par2 != NULL){
         echo 'Par2: '.$mapper -> par2.'<br/>';
      }
   }else{
      echo 'Nie wprowadziłeś wymaganego parametru "par1"!';
   }
?>

Skrypt musi być wywołany przynajmniej z parametrem "par1" w URL'u. Dodatkowo można dodać też "par2". Na co należy zwrócić w nim uwagę? Przede wszystkim na konstrukcję klasy "mapper". Zadeklarowaliśmy w niej jedną z metod jako abstrakcyjną, więc całą klasę również musimy tak oznaczyć. Ponadto do tejże metody nie możemy wprowadzić żadnego kodu. Po przedstawieniu listy parametrów wstawiamy średnik i na tym koniec zabawy. Niech się teraz martwi programista klasy pochodnej :).

Do góry

Koniec części drugiej

Wiesz już, co to jest programowanie obiektowe. Wiesz już, jak ono wygląda w PHP 5. Nauczyłeś się używać dziedziczenia. To jednak nie koniec - do omówienia pozostały nam jeszcze interfejsy, iteratory, rzutowanie typów oraz wyjaśnienie, jak to wszystko zastosować w projektowaniu kodu serwisów WWW. Zapraszam do części trzeciej!

Autor: Tomasz "Zyx" Jędrzejewski, www.zyxist.com

Do góry