Pierwsza część artykułu prezentująca tajniki programowania obiektowego w PHP 5.
Spis treści
Witam w trzyczęściowym artykule poświęconym programowaniu obiektowemu w PHP. Jest to niezwykle ciekawy i dający potężne możliwości element tegoż języka, lecz (co za tym idzie) także skomplikowany. Tajnikom dobrego projektowania aplikacji korzystających z programowania obiektowego można poświęcić kilka grubych książek, tak więc mam świadomość, iż artykuł ten jest tylko początkiem. Dalsza część to już ciężka, ale i owocna praca.
Trochę teorii
Na początek w ogóle powinniśmy zapoznać się z samą strukturą OOP (ang. Object oriented programming - programowanie zorientowane obiektowo). Przyjrzyj się poniższemu schematowi (przepraszam za "estetykę", ale Paint kiepsko radzi sobie z kompresją GIF, a drugiego nie chciało mi się rysować):
Ogółem programy w OOP składają się z dwóch części: obiektów oraz klas, czyli typów tych obiektów, opisujących ich możliwości. Tak też jest to przedstawione na rysunku. Klasa, jako typ, tylko informuje PHP, jakie informacje mają gromadzić oraz jak mają się zachowywać obiekty, czyli rzeczywiste egzemplarze danej klasy, na których możemy wykonywać już konkretne operacje. Główną zaletą OOP jest to, iż możemy ten opis przedstawić jako opis rzeczywistości. Weźmy np. monitor, na który (chyba) teraz patrzysz. Jesteśmy w stanie powiedzieć, iż jest to konkretny obiekt (egzemplarz) klasy "monitor" opisującej zachowanie i parametry monitorów. Jednak każdy obiekt monitora może posiadać inne parametry. Jeden jest czarno-biały, inny kolorowy, jeszcze inny zielono-żółty :) itd. To także widać na schemacie. Klasa zdefiniowała tylko zestaw pól, czyli parametrów, a obiekty trzymają już tam takie dane, jakie im pasują.
Na polach możemy wykonywać operacje poprzez tzw. metody. Są to zwykłe funkcje, tyle że przypisane do konkretnej klasy.
W artykule tym będę omawiał programowanie obiektowe na podstawie nowego PHP 5. W poprzednich wersjach tego języka element ten nie jest dopracowany i ma niewielkie możliwości, a ponadto wersje te niedługo wyjdą z użycia.
Tworzymy klasę
Klasę tworzymy słowem kluczowym class, natomiast jej zawartość ograniczamy klamrami. Pusta klasa to jednak nic ciekawego, dlatego utworzymy sobie pole słowem kluczowym public:
<?php
class klasa{
//zawartosc klasy
public $pole;
}
$obiekt = new klasa;
$obiekt -> pole = 'zawartosc pola'; // 1
echo $obiekt -> pole;
?>
Każda klasa posiada własną nazwę, dzięki której będziemy w stanie ją odróżnić. Nazwę pola poprzedzamy znakiem dolara, a całą jego deklarację kończymy średnikiem. W taki sposób możemy utworzyć kilka pól. Przykład pokazuje ponadto, jak tworzyć obiekty. Robimy to słowem kluczowym new, po którym występuje nazwa klasy. Obiekty są reprezentowane jako zwyczajne zmienne. Przez nie odwołujemy się do pól, operując strzałką (1). Zauważ, że tutaj już nazwa pola nie jest poprzedzona znakiem dolara.
Zapis $obiekt -> pole jest zwyczajnym wyrażeniem, stąd możemy go używać tak, jak innych zmiennych, np.
if($obiekt -> pole == funkcja_jakastam()){
$obiekt -> pole += 5 + time();
itd.
Przypominam, iż możemy stworzyć kilka obiektów danej klasy. Obiekty te posiadają ten sam podstawowy zestaw metod oraz pól, z tym, iż mogą przechowywać inne dane.
<?php
class osoba{
public $imie;
public $nazwisko;
}
$osoby[0] = new osoba;
$osoby[0] -> imie = 'Tomasz';
$osoby[0] -> nazwisko = 'Jędrzejewski';
$osoby[1] = new osoba;
$osoby[1] -> imie = 'Jan';
$osoby[1] -> nazwisko = 'Nowak';
$osoby[2] = new osoba;
$osoby[2] -> imie = 'Piotr';
$osoby[2] -> nazwisko = 'Kowalski';
foreach($osoby as $id => $osoba){
echo ($id + 1).'. '.$osoba -> imie.' '.$osoba -> nazwisko.'<br/>';
}
?>
Utworzyliśmy tutaj trzy obiekty klasy osoba i do każdego wprowadziliśmy inne dane. Obiekty zgrupowaliśmy w tablicy, po czym wyświetliliśmy pętlą foreach. Wyświetliły się wszystkie wprowadzone dane, a zatem potwierdziliśmy, iż możemy utworzyć wiele obiektów pochodnych od danej klasy.
Istotną cechą programowania obiektowego w PHP 5 jest to, iż zmienna obiektowa nie jest obiektem. Obiekt istnieje poza systemem zmiennych PHP, natomiast zmienne obiektowe jedynie na niego wskazują. Oznacza to, iż zrobienie przypisania $obiekt1 = $obiekt2 wcale nie spowoduje utworzenia kopii obiektu! Ilustruje to poniższy przykład:
<?php
class osoba{
public $imie;
public $nazwisko;
public $ksywa;
}
$ja = new osoba;
$ja -> imie = 'Tomasz';
$ja -> nazwisko = 'Jędrzejewski';
$ja -> ksywa = 'Zyx';
echo 'JA: '.$ja -> imie.' '.$ja -> nazwisko.' aka. '.$ja -> ksywa.'<br/>';
$on = $ja; // 1
echo 'Tworzymy $on...<br/>';
$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/>';
?>
A oto rezultat działania:
JA: Tomasz Jędrzejewski aka. Zyx
Tworzymy $on...
ON: Bartosz Maciaszek aka. Sickboy
JA: Bartosz Maciaszek aka. Sickboy
Więc co my tu widzimy? Tworzymy sobie klasę reprezentującą osobę, a następnie jej obiekt. Do obiektu, poprzez $ja wpisujemy odpowiednie dane identyfikujące osobę. Dla pewności wyświetlamy je. Kolejnym krokiem jest stworzenie drugiej zmiennej obiektowej - $on. Wyświetlamy informację o tym, po czym poprzez nowoutworzoną zmienną wprowadzamy nowe dane. Wyświetlamy zawartość $ja oraz $on. Co zaobserwowaliśmy? Pomimo wprowadzania danych poprzez zmienną $on, zmiany widoczne są także w $ja. Oznacza to, że zmienna obiektowa nie jest jednocześnie obiektem. Poszczególne zmienne tego typu przechowują tylko numer konkretnego obiektu. Podczas przypisania $obiekt1 = $obiekt2 został więc przeniesiony tylko on i obie tak zmienne wskazują na jeden i ten sam obiekt - są referencjami:
W poprzednim przykładzie również wykorzystaliśmy tę właściwość programowania obiektowego w PHP. Gdzie? W pętli foreach. Pętla ta przypisywała kolejne obiekty z naszej tablicy do zmiennej $osoba, jednak nie kopiowała wcale tych obiektów, lecz tworzyła do nich nową referencję w tejże zmiennej. Wskazywała więc ona na ten sam obiekt, co i któryś z elementów tablicy i gdyby poprzez nią wprowadzić do niej zmiany, byłyby one od razu "widziane" poza pętlą. W tym przypadku takie działanie jest jak najbardziej pożądane - po co mamy kopiować kolejne obiekty, skoro chcemy je wyświetlić? Drugi "odnośnik" do już istniejących obiektów wystarczy nam w zupełności, a zyski będą znaczne - brak operacji kopiowania to większa prędkość działania skryptu.
Do tego tematu powrócimy w trzeciej części artykułu.
Metody
Ważnym elementem programowania obiektowego są metody. To one pozwalają wykonywać wszelkie operacje na danych obiektu. Jak wspomniałem, przypominają one zwyczajne funkcje. Dlaczego? Zaraz zobaczysz:
<?php
$podatek = 0.22;
$przelicznik = array('pln' => 1.5, 'eur' => 0.5, 'usd' => 0.6);
class wartosc_pieniezna{
public $wartosc;
public function dodaj_podatek(){ // 1
global $podatek;
$this -> wartosc = $this -> wartosc + $this -> wartosc * $podatek;
} // dodaj_podatek();
public function odsetki($procent){ // 2
$odsetki = new wartosc_pieniezna;
$odsetki -> wartosc = $this -> wartosc * $procent;
return $odsetki;
} // end odsetki();
public function przelicz($waluta){ // 3
global $przelicznik;
return $this -> wartosc * $przelicznik[$waluta];
} // end przelicz();
}
$cena = new wartosc_pieniezna;
$cena -> wartosc = 33000;
echo 'Cena netto w dolarach amerykańskich: '.$cena -> przelicz('usd').'<br/>';
$cena -> dodaj_podatek();
echo 'Cena z podatkiem w dolarach amerykańskich: '.$cena -> przelicz('usd').'<br/>';
$odsetki = $cena -> odsetki(0.13);
echo 'Odsetki od ceny w euro: '.$odsetki -> przelicz('eur').'<br/>';
?>
W tym przykładzie napisaliśmy swoisty kalkulator finansowy :). Obiekty typu wartosc_pieniezna przechowują informację o ilości pieniędzy w jakiejś abstrakcyjnej walucie. Przy pomocy metod (1,2,3) możemy tę wartość dowolnie przekształcać oraz przeliczać na różne waluty. Tak więc mamy tutaj doliczanie podatku (1), tworzenie nowego obiektu pieniężnego przechowującego odsetki od naszej kwoty (2), a także przeliczanie jej na rozmaite waluty (3). Mała uwaga dla czepialskich: kursy walut wziąłem sobie z kosmosu, gdyż tutaj akurat one nie są ważne :).
Metod używa się tak, jak zwykłych funkcji. Jedyny warunek to poprzedzenie ich nazwą zmiennej obiektowej oraz strzałką, by te wiedziały, które dane należy przetwarzać :). Tworzenie metod jest również proste - dochodzi tylko słowo kluczowe public oraz konieczność napisania kodu metody wewnątrz klasy.
Ciekawy jest sposób odwoływania się do właściwości (oraz innych metod) w danym obiekcie - Zauważ, jak pobieramy np. w metodzie przelicz() kwotę pieniężną przechowywaną w obiekcie. Używamy specjalnej zmiennej specjalnej $this ZAWSZE wskazującej na obiekt, z którego dana metoda została wywołana. I to jest klucz do sukcesu.
Co to jest to
Zapewne zauważyłeś, że zarówno deklaracje pól, jak i metod, poprzedzone są słowem kluczowym public. Jakie jest jego zadanie? Otóż wyobraź sobie klasę, w której zdefiniowany jest zestaw metod i pól. Niestety, nie wszystkie są przeznaczone do dostępu z zewnątrz - część istnieje tylko na wewnętrzny użytek obiektów i nawet nie powinna być modyfikowana przez programistę! Jak się zabezpieczyć? Tutaj przychodzi z pomocą kontrola dostępności do właściwości obiektu. Każde pole lub metodę możemy poprzedzić jednym z tych trzech słów kluczowych określających, jak duży jest dostęp do danych: public, private, protected. Pierwsze z nich już znamy i chyba łatwo się domyślić, że daje ono pełen dostęp do danej właściwości. Drugie słowo natomiast informuje PHP, iż dostęp do właściwości/metody danej klasy jest możliwy WYŁĄCZNIE z wnętrza metod do niej należących. Nie będziemy mogli zatem napisać $obiekt -> pole_prywatne, gdyż PHP wygeneruje błąd. Jedyną możliwością będzie użycie $this wewnątrz metody należącej do tejże klasy: $this -> pole_prywatne. Trzecim polem zajmiemy się dokładnie później, na razie wystarczy ci wiedzieć, że robi mniej więcej to samo, co private.
Jak to wszystko wygląda w praktyce?
<?php
class tablica {
private $tablica;
private $count;
public function dodaj_element($wartosc){
$this -> tablica[$this -> count++] = $wartosc;
} // end dodaj_element();
private function generuj($id, $typ){
if($typ == 0){
echo 'INSERT INTO tabela (pole) VALUES(\''.$this->tablica[$id].'\');<br/>';
}elseif($typ == 1){
echo '<li>'.$id.'. '.$this->tablica[$id].'</li>';
}else{
echo $this -> tablica[$id];
}
} // end generuj();
public function lista($typ){
if($typ == 1){
echo '<ul>';
}
for($i = 1; $i < $this -> count; $i++){
$this -> generuj($i, $typ);
}
if($typ == 1){
echo '</ul>';
}
} // end lista();
public function pokaz($num){
if($num < $this -> count){
$this -> generuj($num, 2);
}
} // end pokaz();
}
$lista = new tablica;
for($i = 0; $i < 15; $i++){
$lista -> dodaj_element(rand(1, 300));
}
$lista -> lista(1);
echo 'Wartość elementu 8 to ';
$lista -> pokaz(8);
echo '<br/>';
?>
Napisaliśmy tu sobie prostą strukturę danych. Mniejsza o to, iż jej budowa jest lekko niezgodna z "kanonem" pisania tego typu kawałków kodu :). My tu zajmujemy się programowaniem obiektowym. Zatem, co to jest nowego? Ano słowa kluczowe private nadane wszystkim polom oraz jednej metodzie klasy. Zaznaczyliśmy tym samym, iż dostęp do nich będą miały wyłącznie inne metody tejże klasy. Nie jesteśmy więc w stanie napisać np. $lista -> generuj(5,1);, gdyż metoda generuj() jest metodą prywatną. Podobnie z polami. Tylko $this i tylko w metodach należących do tej samej klasy. Możesz z resztą poeksperymentować w ten sposób, by przekonać się, iż jest to prawda.
Konstruktory i destruktory
W powyższych przykładach wszystkie dane pracowicie wpisywaliśmy ręcznie już po zainicjowaniu obiektu danej klasy. Na szczęście nie jest to konieczne. Jako programiści bowiem, mamy możliwość stworzenia w naszych klasach dwóch metod specjalnych - construct() oraz destruct(). Pierwsza jest wywoływana w momencie inicjacji obiektu (konstruktor obiektu), natomiast druga podczas jego niszczenia (destruktor obiektu). Możemy dzięki temu stworzyć sterownik do bazy danych - konstruktor ustanowi połączenie, a destruktor zamknie je na końcu pracy skryptu automatycznie. Ale uwaga - jako że są to metody specjalne, mają też specjalne wymagania! I tak - w construct() nie możemy użyć instrukcji return, czyli nie mamy możliwości zwrócenia wyniku. To samo ograniczenie występuje w destruktorze. Ten jednak dodatkowo nie może pobierać żadnych parametrów! Zatem napisanie np. function destruct($x) spowoduje błąd.
Dla zademonstrowania działania destruktora i konstruktora, utworzymy sobie prosty sterownik dla bazy PostgreSQL:
<?php
class sql{
private $link;
private $result;
public $rows;
public function __construct($host, $dbname, $user, $port, $pass = ''){ // 1
echo 'Wywołanie konstruktora<br/>';
$this -> link = pg_connect('host='.$host.' port='.$port.' user='.$user.' dbname='.$dbname.' '.($pass != '' ? 'password='.$pass : ''));
if(!is_resource($this -> link)){
die('Brak połączenia z bazą!');
}
} // end __construct();
public function __destruct(){ // 2
echo 'Wywołanie destruktora<br/>';
if(is_resource($this -> link)){
}
} // end __destruct();
public function query($query){
$this -> result = pg_query($this->link, $query);
if(strlen(($msg = pg_last_error($this->link))) > 0){
die('Błąd: '.$msg);
}
} // end query();
public function fetch_row(){
if($this -> rows = pg_fetch_row($this -> result)){
return 1;
}
} // end fetch_row();
}
$sql = new sql('localhost', 'demo', 'zyx', '5432'); // 3
echo 'Zawartość bazy "test":<ul>';
$sql -> query('SELECT tekst FROM test ORDER BY id');
while($sql -> fetch_row()){
echo '<li>'.$sql -> rows[0].'</li>';
}
echo '</ul>';
?>
Jeżeli korzystasz z innego systemu baz danych, raczej nie powinieneś mieć problemów z przeróbką tego przykładu. W każdym razie - pomimo tego, iż nigdzie jawnie nie wywołaliśmy konstruktora (1), pojawił się w przeglądarce napis "Wywołanie konstruktora", a połączenie z bazą zostało utworzone. Gdzie zatem nastąpiło wywołanie? Przypatrz się linii oznaczonej numerkiem "3" - to tutaj. Operator new wywołuje konstruktor, a na przykładzie możesz zauważyć, jak wprowadzić do niego rozmaite parametry! I tak to się robi.
Natomiast co do destruktora... tego w ogóle nie wywoływaliśmy, zarówno jawnie, jak i niejawnie, a mimo to napis "Wywołanie destruktora" się pojawił. Co jest więc grane? Ano po prostu PHP w momencie kończenia pracy skryptu niszczył po kolei wszystkie obiekty, dla każdego z nich uruchamiając destruktor (o ile takowy istniał). I dzięki temu my nie musieliśmy w ogóle dbać o zamknięcie połączenia - nasz obiekt zrobił to za nas. Tu jawi się kolejna zaleta programowania obiektowego - wiele czynności można zautomatyzować i dostosować do naszej koncepcji, odciążając tym samym nas w wielu momentach i zmniejszając ilość okazji do popełnienia błędów.
Konstruktory i destruktory to nie jedyne metody specjalne. Jest jeszcze sześć innych...
__get(), __set() i __call()
Te trzy metody specjalne są dla programisty niezwykle użyteczne, bowiem obsługują żądania dostępu do pól i metod. Co to oznacza? Otóż dzięki nim możemy "wychwycić" np. przypisanie jakiejś wartości do pola i wykonać przy tym dodatkową akcję. Jest jednak pewien haczyk :). Wychwytywać możemy tylko żądania dostępu do niezadeklarowanych w klasie pól i metod. Więc jeżeli nasza klasa będzie zawierała pole $imie, a my dla jakiegoś jej obiektu wywołamy np. $obiekt -> imie, to nic się nie stanie. Kiedy jednak takowego pola nie stworzymy, przy próbie jego wywołania uruchomi się cichaczem metoda get(), ew. set() i obsłuży dane żądanie w jakiś tam sposób. Jest to nieprawdopodobnie użyteczne...
Ano właśnie, do czegóż nam się to przyda? Jeśli nie mamy związanych z tym jakichś specjalnych planów, możemy tego użyć do zwyczajnego wyłapywania naszych własnych pomyłek, co ułatwi nam debugowanie programu. Bowiem jedną z cech, po jakiej można poznać dobrego programistę, jest wykorzystywanie struktur danego języka programowania do wyłapywania własnych błędów. Tu właśnie coś takiego chciałem zaprezentować...
<?php
class osoba{
public $imie;
public $nazwisko;
public function __construct($imie, $nazwisko){
// Inicjujemy obiekt
$this -> imie = $imie;
$this -> nazwisko = $nazwisko;
} // end __construct();
public function wez_nazwe(){
return $this->imie.' '.$this -> nazwisko;
} // end wez_nazwe();
public function __get($nazwa){
echo 'Chyba popełniłeś literówkę, wywołując $obiekt -> '.$nazwa.'!<br/>';
} // end __get();
public function __set($nazwa, $wartosc){
echo 'Chyba popełniłeś literówkę, próbując przypisać "'.$wartosc.'" do nieistniejącego $obiekt -> '.$nazwa.'!<br/>';
} // end __get();
public function __call($nazwa, $parametry){
echo 'Chyba popełniłeś literówkę, próbując wywołać nieistniejącą metodę '.$nazwa.'()!<br/>';
} // end __get();
}
$osoba1 = new osoba('Tomasz', 'Jędrzejewski');
$osoba2 = new osoba('Bartosz', 'Maciaszek');
echo 'Osoba 1 ('.$osoba1->wez_nazwe().') ma na imię '.$osoba1->imie.'<br/>';
echo 'Osoba 2 ('.$osoba2->wez_nawze().') ma na imię '.$osoba2->ime.'<br/>';
$osoba2 -> nawzisko = 'Nowak';
?>
OK, stworzyliśmy sobie tutaj dwa obiekty klasy osoba. Dane pierwszej osoby się wyświetlają prawidłowo. Jednak przy wywoływaniu personaliów osoby drugiej, a później także przy zmianie nazwiska, popełniliśmy same literówki :). Najpierw - zamiast wez_nazwe() napisaliśmy wez_nawze() i takie nieprawidłowe wywołanie przeszło do metody call(), która wygenerowała stosowny komunikat. Co prawda w tym przypadku akurat sam PHP poradziłby sobie znacznie lepiej, wyświetlając "Fatal error: Call to undefined method on line xxx in file yyy" :), ale przy polach już nie ma tak dobrze, bowiem parser języka przewiduje możliwość swobodnego operowania na nieistniejących polach (po prostu utworzy takowe w locie). I tu przydają się get() przechwytująca żądania odczytu z niezdefiniowanych pól oraz set() obsługująca wprowadzanie danych. Dzięki nim od razu połapiemy się, dlaczego nie wyświetliły/zmieniły się jakieś informacje, wystarczy już tylko odszukać miejsce. Oszczędzamy więc czas i nerwy ("A: @#$@#$@, czemu to @#@#$ nie działa!? B: O, tu masz literówkę. A: @#$@$@$!" :)).
Teraz troszkę danych technicznych. get() pobiera jeden parametr określający nazwę pola do odczytu. Może zwracać wartość, wtedy zostanie to potraktowane jako wartość tego nieistniejącego pola. set() pobiera dwa parametry - nazwę pola oraz wartość, jaką do niego chcemy przypisać. call() - również dwa: nazwę metody i tablicę z parametrami doń przekazanymi.
Teraz dość abstrakcyjny, acz ciekawy przykład wykorzystania tych metod specjalnych, bazujący na metodzie __call():
<?php
class logger{
private $osoby;
public function wyswietl_liste_osob(){
foreach($this -> osoby as $osoba){
echo $osoba[0].' (wiek: '.$osoba[1].')<br/>';
}
} // end wyswietl_liste_osob();
public function __call($nazwa, $parametry){
if(count($parametry) == 1){
$this -> osoby[] = array(0 => (string)$nazwa, $parametry[0]); // 1
}
} // end __call();
}
$jumpreza = new logger;
$jumpreza -> rufus(21);
$jumpreza -> iza(20);
$jumpreza -> mateusz(21);
$jumpreza -> agata(21);
echo 'Lista zaproszonych: <br/>';
$jumpreza -> wyswietl_liste_osob();
?>
Podana tu klasa posiada metodę __call() przechwytującą wszystkie (za wyjątkiem wyswietl_liste_osob()) żądania uruchomienia jakiejś metody. Żądania te są interpretowane jako... dodawanie osób do imprezy. Nazwa metody zaczyna robić za imię, natomiast jedyny parametr - za wiek danej osoby. Widzimy więc, iż trzy omówione w tym rozdziale metody specjalne można wykorzystać na wiele sposobów ograniczonych tylko twoją fantazją :). Jednak dobrze radzę - lepiej, aby ich użycie było logicznie i racjonalnie uzasadnione, gdyż w przeciwnym wypadku może z tego być więcej problemów, niż pożytku. Ponadto chciałbym zwrócić uwagę, iż nazwa metody/pola w tych metodach jest w rzeczywistości zwykłą referencją (tyle że nie wiem, do czego), dlatego gdy chcemy ją zapisać (tak, jak w tym przypadku) poza daną metodą, musimy wymusić na PHP konwersję zmiennej do ciągu tekstowego (zapis (string)$nazwa w linijce oznaczonej numerem 1).
Funkcja __autoload()
Oprócz metod specjalnych, PHP 5 niesie ze sobą jedną (i jak na razie jedyną) funkcję specjalną - autoload(). Wywoływana jest ona, gdy próbujemy stworzyć obiekt nieistniejącej klasy. Jak to możemy wykorzystać? Załóżmy, iż piszesz silnik do strony WWW oparty o programowanie obiektowe. Nie chce Ci się dołączać ręcznie wszystkich plików ze źródłami - zamiast tego wykorzystujesz metodę autoload(), która przechwyci żądanie utworzenia obiektu od jakiejś klasy, po czym załaduje do pamięci kod tejże klasy automatycznie. Ot, co:
<?php
function __autoload($nazwa){
require('./silnix/lib.'.$nazwa.'.php');
} // end __autoload();
$engine = new engine;
$io = new io;
$tpl = new tpl;
$config = new config;
?>
Najpierw inicjalizujemy obiekt klasy engine. Ta nie jest załadowana, lecz żądanie przechwytuje funkcja autoload() i dołącza plik lib.engine.php tak, by PHP wiedział, co tworzony obiekt ma zawierać. Później obiekt klasy io - również autoload() automatycznie dołącza plik lib.io.php. Tak samo jest z pozostałymi klasami. Jeszcze raz udało mi się pokazać, iż programowanie obiektowe może znacząca ułatwić twe życie.
Zakończenie części pierwszej
Mam nadzieję, iż artykuł ten wprowadził Cię w świat programowania obiektowego. Nie poprzestawaj na tym. Eksperymentuj sam - w końcu ćwiczenie czyni mistrza. Kolejna część pokaże, jak rozszerzać istniejące już obiekty oraz jak je kopiować.
Autor: Tomasz "Zyx" Jędrzejewski, www.zyxist.com
Wyszukiwarka
Podobne podstrony:
obiektowka PHP, Programowanie
PHP profesjonalnie programowanie obiektowe i narzędzia programisty 08 2006
PHP Programowanie obiektowe phppro
Programowanie obiektowe w PHP 5
PL PHP programowanie obiektowe
PHP Programowanie obiektowe
PHP Programowanie obiektowe phppro
PHP Programowanie obiektowe
PHP Programowanie obiektowe phppro
informatyka programowanie obiektowe w php 5 hasin hayder ebook
więcej podobnych podstron