PHP5
Autor
Wojciech Jurewicz
(OMEGA)
[e-mail]
[e-mail]
http://php.webinside.pl
- 1 -
Spis Tre ci:
Wst p .................................................................................. 3
unifikowane konstruktory .....................................................4
destruktory ...........................................................................5
obiekty jako referencje ........................................................6
klonowanie obiektów ...........................................................7
definiowanie interfejsów ......................................................8
okre lanie metod i w a ciwo ci jako PPP czyli: ................10
- Private .............................................................................10
- Public ..............................................................................10
- Protected .........................................................................10
Klasy abstrakcyjne ............................................................12
elementy statyczne ............................................................13
__call .................................................................................14
__set i __get ......................................................................16
rzutowanie typów ...............................................................17
wyj tki ................................................................................18
definiowanie w asnej obs ugi wyj tków .............................20
pola nazw (ze róde nie oficjalnych) ................................22
zagnie d one pola nazw ...................................................23
__autoload .........................................................................24
final ....................................................................................25
sta e ...................................................................................26
dereferencja obiektów .......................................................27
instanceof ..........................................................................28
warto domy lna parametrów z referencj ......................29
- 2 -
Wst p:
PHP5 nie jest jeszcze oficjalnie oddane do u ytku. Aktualnej wersji mo na u ywa ale zawiera
ona sporo b dów. Wiele elementów jest podobnych albo nawet takich samych w PHP4 i
PHP5, ale oczywi cie s ró nice i to spore. To co przedstawi w tym artykule dzia a w obecnej
wersji, ale do wypuszczenia PHP5 oficjalnie mo e si du o zmieni . Obecn wersje mo esz
ci gn z http://www.php.net i sprawdzi przyk ady które zaprezentuje. W PHP5 zmieniono
stare elementy jak i dodano nowe, tak np. Zmieniono model obiektów tudzie dodano nowe
elementy. Wprowadzono pola nazw oraz wyj tki. Najwi kszy jednak nacisk po o one na
programowanie obiektowe w którym zasz y najwi ksze zmiany, które mo na porówna do
Javy i C++.
- 3 -
konstruktory:
W PHP4 konstruktory musia y nazywa si tak jak dana klasa, czyli np. konstruktor klasy
 jakasklasa nazywa si  jakasklasa . W PHP5 konstruktory s unifikowane, czyli zawsze maj
tak sam nazw : __construct(), tak wi c konstruktor klasy  jakasklasa b dzie nazywa si
 __construct . Nale y pami ta o podwójnym znaku podkre lenia na pocz tku nazwy. W
przyk adzie wygl da to tak:
# Przyk ad 1
class samochod
{
var $akcja;
function __construct() {
$this -> akcja =  start ;
$this -> wykonaj();
}
function wykonaj() {
echo  Silnik  . $this -> akcja . 
 ;
}
}
$ford = new samochod;
?>
# wynik
Silnik start
Dzia anie jest bardzo proste destruktor uruchamia si wraz z definicj obiektu.
- 4 -
Destruktory:
W PHP4 destruktory nie by y dost pne, przez co trzeba by o si czasami zdrowo
nakombinowa aby w razie potrzeby zasymulowa taki pseudo destruktor. Na szcz cie w
PHP5 destruktory s i nazywaj si : __destruct(). Oczywi cie w ka dej klasie ich inicjalizacja
wygl da tak samo. Rozwijaj nasz przyk ad mo emy wykorzysta destruktor do zatrzymania
silnika:
# Przyk ad 2
class samochod
{
var $akcja;
function __construct() {
$this -> akcja =  start ;
$this -> wykonaj();
}
function wykonaj() {
echo  Silnik  . $this -> akcja . 
 ;
}
function __destruct() {
$this -> akcja =  stop ;
$this -> wykonaj();
}
}
$ford = new samochod;
?>
# wynik
Silnik start
Silnik stop
Tutaj równie dzia anie jest proste, destruktor uruchamia si wraz z "niszczeniem" obiektu, w
tym wypadku kiedy skrypt ko czy dzia anie.
- 5 -
Obiekty jako referencje:
W PHP4 mo na by o u ywa pewnego rodzaju referencji, u ywaj c znaku & przy zmiennych,
w wyniku czego nie by y kopiowane. Jest to co w rodzaju wska ników. Je eli chodzi o obiekty
w PHP5, to w wypadku przypisywania obiektu jest automatycznie tworzona referencja do tego
obiektu. Znaczy to e gdy przypisujemy obiekt do zmiennej to tworzymy do niego referencj .
Drobny przyk ad powinien wyja ni to dzia anie w tym wypadku:
# Przyk ad 3
class samochod
{
var $model;
function pokaz() {
echo $this -> model . 
 ;
}
}
$merc = new samochod;
$ford = $merc;
$merc -> model =  clk ;
$merc -> pokaz();
$ford -> model =  mustang ;
$ford -> pokaz();
$merc -> pokaz();
?>
# wynik
clk
mustang
mustang
Jak wida nie zosta y utworzone dwie kopie tego samego obiektu, tylko zosta a utworzona
referencja i to bez potrzeby u ycia &.
- 6 -
Klonowanie obiektów:
Jako e obiekty s przekazywane automatycznie przez referencj , t mo e zaj potrzeba ich
kopiowania aby tworzy niezale ne od siebie kopie, co mo e przyda si przy traktowaniu
obiektów jako swoistych "magazynów" do czego cz z was przyzwyczai a si w PHP4. Aby
sklonowa obiekt u ywamy predefiniowanej metody __clone(). Dzia a to na zasadzie
przypisania, gdzie z lewej strony umieszczamy obiekt który chcemy sklonowa wywo uj c
__clone(), a z lewej zmienn do której ma by zapisana kopia obiektu. W praktyce wygl da to
tak:
# Przyk ad 4
class samochod
{
var $model;
function pokaz() {
echo $this -> model . 
 ;
}
}
$merc = new samochod;
$ford = $merc -> __clone();
$merc -> model =  clk ;
$merc -> pokaz();
$ford -> model =  mustang ;
$ford -> pokaz();
$merc -> pokaz();
?>
# wynik
clk
mustang
clk
Jak wida obydwie kopie s od siebie nie zale ne, co pozwala trzyma kopie ró nych
zmiennych w ró nych obiektach
- 7 -
Definiowanie interfejsów:
Zarówno w PHP4 jak i w PHP5 mo liwe jest dziedziczenie tylko z jednej klasy. Zdarza y si
przypadki gdzie to ograniczenie skutecznie pl ta o projekt kodu tworz c np. zbyt popl tane
drzewo w hierarchii klas. Ale w PHP5 jest z tego wyj cie. Mo liwe jest definiowanie interfejsów
w których w rzeczywisto ci nie ma adnych metod. W interfejsie definiuje si tylko nazwy i
parametry metod, które mog by potem u yte w klasie do której zaimplementujemy dany
interfejs. W odró nieniu od zwyk ego dziedziczenia mo emy do klasy przypisa tyle interfejsów
ile tylko nam si podoba, z tym e w klasie musz by zdefiniowane te metody które wyst puj
w interfejsach, tym razem w ca o ci. Do klasy do czamy interfejsy za pomoc s owa
kluczowego implements, oddzielaj c kolejne interfejsy przecinkami. W praktyce wygl da to
tak:
# Przyk ad 5
interface silnik {
function start( $samochod );
function stop( $samochod );
}
interface bagaznik {
function otworz();
function zamknij();
}
class samochod
implements silnik,bagaznik
{
function start( $samochod ) {
echo  Samochód . $samochod .  w czony. ;
}
function stop( $samochod ) {
echo  Samochód . $samochod .  wy czony. ;
}
function otworz() {
echo  Baga nik otwarty. ;
}
function zamknij() {
echo  Baga nik zamkni ty. ;
}
}
$mojsamochod = new samochod;
$mojsamochod -> start( 'ford' );
$mojsamochod -> otworz();
$mojsamochod -> zamknij();
$mojsamochod -> stop( 'ford );
?>
# wynik
- 8 -
Samochód ford w czony.Baga nik otwarty. Baga nik zamkni ty.Samochód ford
wy czony.
Zapytacie po co to... Dzi ki temu kod jest bardziej czytelny. W definiowanych interfejsach
wida na pierwszy rzut oka co jest, a co jest w klasie wida ju na pocz tku jej deklaracji dzi ki
interfejsom. Pozwala to utrzyma ad w kodzie. W powy szym kodzie ju po pierwszych dwóch
linijkach deklaracji klasy wiadomo jakie b dzie ona mia a metody i czego te metody potrzebuj .
Nie wa ne jak dzia aj , mo e to wyja nia komentarz, wa ne e mo na si do nich odwo a i
jest to jasne w jaki sposób.
- 9 -
Okre lanie metod i w a ciwo ci jako PPP czyli:
W PHP4 do ka dej metody i w a ciwo ci mo na by o dosta si spoza obiektu. Mo na
powiedzie e one wszystkie by y okre lone domy lnie jako publiczne. W PHP5 wprowadzono
3 modyfikatory które zmieniaj posta rzeczy. Dzi ki im mo emy ustawi dost p do danej
metody lub w a ciwo ci. Te modyfikatory to Private, Public i Protected.
Private: Dost p do metody lub w a ciwo ci okre lonej jako Private maj tylko metody z tej
samej klasy, czyli w klasach potomnych i z zewn trz nie ma dost pu.
Public: Do metody lub w a ciwo ci okre lonej jako Public dost p jest mo liwy zarówno w
klasach potomnych jak i z zewn trz obiektu.
Protected: Do metody lub w a ciwo ci okre lonej jako protected maj dost p tylko metody z tej
samej lub potomnej klasy, czyli z zewn trz nie ma dost pu. W praktyce wygl da to tak:
# Przyk ad 6
class samochody_zapisz
{
private $ford;
public $audi;
protected $mercedes;
private function zapisz_ford( $model ) {
$this -> ford = $model;
}
public function zapisz_audi( $model ) {
$this -> audi = $model;
}
protected function zapisz_mercedes( $model ) {
$this -> mercedes = $model;
}
}
class samochody_pokaz extends samochody_zapisz
{
private function pokaz_ford() {
echo $this -> ford;
}
public function pokaz_audi() {
echo $this -> audi;
}
protected function pokaz_mercedes() {
echo $this -> mercedes;
}
public function wyswietl() {
//echo $this -> ford; //nie dziala
echo $this -> audi; //dziala
echo $this -> mercedes; //dziala
$this -> pokaz_ford(); //dziala
$this -> pokaz_audi(); //dziala
- 10 -
$this -> pokaz_mercedes(); //dziala
}
}
$zapisz = new samochody_zapisz;
$pokaz = new samochody_pokaz;
//$zapisz -> zapisz_ford('mustang'); //nie dziala
$zapisz -> zapisz_audi( 'a8' ); //dziala
//$zapisz -> zapisz_mercedes('clk'); //nie dziala
//$pokaz -> zapisz_ford('mustang'); //nie dziala
$pokaz -> zapisz_audi( 'a8' ); //dziala
//$pokaz -> zapisz_mercedes('clk'); //nie dziala
//$pokaz -> pokaz_ford(); //nie dziala
$pokaz -> pokaz_audi(); //dziala
//$pokaz -> pokaz_mercedes(); //nie dziala
$pokaz -> wyswietl(); //dziala
?>
Wyniku nie b d przedstawia gdy kod zawiera elementy b dne (umieszczone w
komentarzach). Oczywi cie kod z wykomentowanymi b dami zadzia a.
- 11 -
Klasy abstrakcyjne:
Tego w PHP4 te nie by o. Co to jest..? Mo na powiedzie e abstrakcyjne elementy nie s
przeznaczone bezpo rednio do u ytku, tzn., je eli deklarujemy ca klas , lub chocia jedn
metod danej klasy jako abstrakcyjn nie b dzie mo na utworzy obiektu tej klasy, tzn.
pojedynczego egzemplarzu. Przydaj si to w dziedziczeniu, poniewa niektóre klasy
tworzone s tylko po to, aby kilka innych mog o z nich dziedziczy . Jak natomiast ma si
sprawa co do dziedziczenia abstrakcyjnych metod, otó je eli okre lamy metod jako
abstrakcyjn , tylko j definiujemy, natomiast inicjalizacja tej metody musi odby si w klasie
potomnej. Oznacza to e nie wszystkie metody w klasie abstrakcyjnej musz by abstrakcyjne.
W przyk adzie wygl da to tak:
# Przyk ad 7
abstract class silnik
{
protected $modelsamochodu;
public function wlaczsilnik() {
echo $this -> modelsamochodu .  silnik w czony. ;
}
abstract function wylaczsilnik();
}
class samochod extends silnik
{
public function zapiszmodel( $model ) {
$this -> modelsamochodu = $model;
}
public function wylaczsilnik(){
echo $this -> modelsamochodu .  silnik wy czony. ;
}
}
$ford = new samochod;
$ford -> zapiszmodel( 'mustang' );
$ford -> wlaczsilnik();
$ford -> wylaczsilnik();
?>
# wynik
mustang silnik w czony.mustang silnik wy czony.
Jak wida jest czytelniej. Mo na by o obie metody z klasy silnik ustawi jako abstrakcyjne, ale
chcia em pokaza ró nic .
- 12 -
Elementy statyczne:
Elementów statycznych mo na u ywa jako tzw. metod i zmiennych klasy (class method i
class variable). Dzi ki temu mo na si do nich odwo ywa bezpo rednio z poziomu klasy, tzn.
bez potrzeby tworzenia obiektu danej klasy. Dost p do nich mo emy uzyska poprzez "::".
Elementy statyczne mog by inicjalizowane, tzn. mog mie warto pocz tkow . W praktyce
wygl da to tak:
# Przyk ad 8
class samochod
{
static public $model = 'mustang';
static public function przejazdzka( $gdzie ) {
echo  Jedziemy do  . $gdzie .  i wracamy ;
}
}
echo samochod::$model . '
';
samochod::przejazdzka( 'Warszawa' );
?>
# wynik
mustang
Jedziemy do Warszawa i wracamy.
Dzi ki temu mo emy korzysta z zawarto ci klas bez tworzenia ich egzemplarzy.
- 13 -
__call:
Jest to specjalna metoda, któr mo emy zdefiniowa wewn trz klasy. S u y ona do
przechwytywania wywo a metod nie istniej cy lub nie dost pnych. W wypadku gdy odwo asz
si do takiej, zostanie u yta funkcja __call() (je eli zosta a zdefiniowana) która przechwyci
nazw wywo ywanej metody i list jej parametrów w postaci tablicy. Metoda call posiada dwa
parametry nazw i parametry wywo ywanej metody. Metod __call() mo na wykorzysta do
prze adowywania metod. U ycie metody __call() wygl da nast puj co:
# Przyk ad 9
class samochod
{
function __call( $nazwa, $parametry ) {
echo  Wywo a e /a metod  . $nazwa;
}
}
$ford = new samochod;
$ford -> jakasmetoda();
?>
# wynik
Wywo a e /a metod jakasmetoda
Natomiast je eli chodzi o prze adowywanie to sprawa ma si równie prosto, przyk adowe
prze adowanie metody mo e wygl da tak:
# Przyk ad 10
class samochod
{
function __call( $funkcja, $parametry ) {
if ($funkcja == 'otworz') {
switch ( $parametry[0] ) {
case 'dzwi':
$this -> otworzdzwi();
break;
case 'bagaznik':
$this -> otworzbagaznik();
break;
default:
echo 'Nic takiego nie otworze';
break;
}
} else {
echo 'Nie ma takiej metody';
}
}
- 14 -
function otworzbagaznik() {
echo 'Baga nik otwarty';
}
function otworzdzwi() {
echo 'D wi otwarte';
}
}
$ford = new samochod;
$ford -> otworz( 'dzwi' );
$ford -> otworz( 'bagaznik' );
$ford -> otworz( 'maske' );
$ford -> startsilnika();
?>
# wynik
D wi otwarte.Baga nik otwarty.Nic takiego nie otworze.Nie ma takiej metody.
Jak wida jest to prosty sposób na prze adowywanie metod podobnie jak w innych j zykach
programowania.
- 15 -
__set i __get:
Tutaj sprawa ma si podobnie do __call(), z t ró nic e __set() i __get() s u do
przechwytywania w a ciwo ci (zmiennych) w obiekcie. Pytanie po co a dwie, a no po to eby
obs u y prób zapisu i odwo anie si do danej w a ciwo ci, w metodach to nie by o
potrzebne. I tak __set() przechwytuje zmienne które próbujemy ustawi , posiada dwa
parametry, pierwszy to nazwa zmiennej, a drugi to jej warto . __get() natomiast przechwytuje
odwo anie si do zmiennej i posiada jeden parametr którym jest nazwa zmiennej. U ycie
__set() wygl da nast puj co:
# Przyk ad 11
class samochod
{
function __set( $nazwa, $wartosc ) {
echo  Próbujesz ustawi zmienn  . $nazwa .  na  . $wartosc .  . ;
}
}
$ford = new samochod;
$ford -> model = 'mustang';
?>
# wynik
Próbujesz ustawi zmienn model na mustang.
Mo esz w ten sposób zapisywa warto ci poprzez zmienne np. do odpowiedniej tablicy przy
u yciu wcze niej zdefiniowanej metody który by wykonywa a wewn trz __set().
Je eli chodzi o __get() to sprawa ma si nast puj co:
# Przyk ad 12
class samochod
{
function __get( $nazwa ) {
echo  Próbujesz uzyska dost p do zmiennej  . $nazwa .  . ;
}
}
$ford = new samochod;
echo $ford -> model;
?>
# wynik
Próbujesz uzyska dost p do zmiennej model.
Tego natomiast mo na u y do odczytywania bardziej z o onych struktur, chocia by tablic,
równie przy u yciu odpowiedniej metody która by potrafi a to obs u y .
- 16 -
Rzutowanie typów:
Nie jest to mo e dos ownie takie rzutowanie typów jak w innych je ykach programowania, ale
co z tej dziedziny. Mo liwo jest taka, e mo na okre li w definicji funkcji której klasy obiekt
musi by podany jako argument, tzn. Podaj c list parametrów w definicji, to przed
konkretnym parametrem umieszczamy nazw klasy której obiekt mo e by danym
parametrem. Przyk adowo wygl da to tak:
# Przyk ad 13
class samochod
{
public $model;
}
class garaz
{
public function parkoj( samochod $samochod ) {
echo $samochod -> model .  zosta zaparkowany. ;
}
}
$ford = new samochod;
$ford -> model = 'mustang';
$garaz = new garaz;
$garaz -> parkoj( $ford );
?>
# wynik
mustang zosta zaparkowany.
Niby co za ró nica, ale pomaga w pisaniu programu i pozwala si wystrzec nie potrzebnych
b dów, które zw aszcza mog by problemem podczas gdy kilku programistów pracuje przy
jednym projekcie.
- 17 -
Wyj tki:
Wyj tki w PHP5, podobnie jak w innych j zykach programowania to dobra rzecz do obs ugi
b dów i nie przewidzianych sytuacji. Mo emy sami okre li co gdzie i jak ma by zrobione na
wypadek nie przewidzianej sytuacji, czyni c aplikacj bardziej przyst pn . Do obs ugi
wyj tków w PHP5 s u trzy s owa kluczowe: try, catch i throw. Obs uga wyj tków jest
zapisana w predefiniowanej klasie Exception. Kod który chcemy przetestowa umieszczamy w
bloku try, a obs ug wyj tku w bloku catch. Przyk adowa standardowa obs uga wyj tków
wygl da nast puj co:
# Przyk ad 14
class samochod
{
public $samochod;
public function start( $mojsamochod ) {
if ( $this -> samochod != $mojsamochod ) {
throw new Exception(  Nie mam takiego samochodu. );
} else {
echo  Samochód  . $mojsamochod .  wystartowa ... ;
}
}
}
$ford = new samochod;
$ford -> samochod = 'mustang';
try {
$ford -> start( 'mustang' );
} catch ( Exception $e ) {
echo $e -> getMessage();
}
?>
# wynik
Samochód mustang wystartowa ...
Je eli natomiast podamy nieprawid owy samochód, zostanie wygenerowany b d:
# Przyk ad 15
class samochod
{
public $samochod;
public function start( $mojsamochod ) {
if ( $this -> samochod != $mojsamochod ) {
throw new Exception(  Nie mam takiego samochodu. );
- 18 -
} else {
echo  Samochód  . $mojsamochod .  wystartowa ... ;
}
}
}
$ford = new samochod;
$ford -> samochod = 'mustang';
try {
$ford -> start( 'mondeo' );
} catch ( Exception $blad ) {
echo $blad -> getMessage();
}
?>
# wynik
Nie mam takiego samochodu.
- 19 -
Definiowanie w asnej obs ugi wyj tków:
Tutaj sprawa ma si podobnie do zwyk ej obs ugi wyj tków. Chodzi o to e mo emy
rozszerzy standardow obs ug wyj tków rozszerzaj c standardow klas Exception o
nasz , w której mo emy u y w asnych meto do tej obs ugi. Trzeba tylko pami ta , aby w
naszej klasie potomnej umie ci odpowiedni konstruktor, który b dzie inicjalizowa metod
exception() z klasy potomnej Exception, oraz nale y zdefiniowa metod która zwróci
komunikat b du. W praktyce wygl da to tak:
# Przyk ad 16
class nowewyjatki extends Exception
{
private $blad;
function __construct( $blad ) {
parent::exception();
$this -> blad = $blad;
}
function getMessage() {
return $this -> blad .  jest przyczyn b du. ;
}
}
?>
Mo na równie doda metod z wyj tków: getFile() która zwraca nazw pliku w którym
wyst pi b d. Stosuj c powy sz klas nasz poprzedni kod móg by wygl da nast puj co:
# Przyk ad 17
class nowewyjatki extends Exception
{
private $blad;
function __construct( $blad ) {
parent::exception();
$this -> blad = $blad;
}
function Komunikat() {
return $this -> blad .  jest przyczyn b du. ;
}
}
class samochod
{
public $samochod;
public function start( $mojsamochod ) {
- 20 -
if ( $this -> samochod != $mojsamochod ) {
throw new nowewyjatki(  Nie mam takiego samochodu );
} else {
echo  Samochód  . $mojsamochod .  wystartowa ... ;
}
}
}
$ford = new samochod;
$ford -> samochod = 'mustang';
try {
$ford -> start( 'mondeo' );
} catch ( nowewyjatki $blad ) {
echo $blad -> Komunikat();
echo "\nW pliku: " . $blad -> getFile();
}
?>
# wynik
Nie mam takiego samochodu jest przyczyn b du. W pliku:
C:\apache\htdocs\php\index.php
Na pierwszy rzut oka nie wida ró nicy, ale takowa jest, poniewa mo na dodawa wi cej
metod które b d obs ugiwa y ró ne wyj tki. Mo na polepszy obs ug i wy wietlanie b dów
dzi ki wyj tkom które sami zdefiniujemy.
- 21 -
Pola nazw:
W php5 mo na u ywa pól nazw do grupowania klas lub funkcji. W oddzielnych polach nazw
mo emy deklarowa np. ró ne klasy o tych samych nazwach. Mo e to by u yteczne np. gdy
chcemy wykorzysta ten sam interfejs do wykonania ró nych czynno ci. Przyk adowe u ycie
pola nazw mo e wygl da nast puj co:
# Przyk ad 18
namespace motoryzacja {
class samochod {
function __construct() {
echo  Klasa samochód z pola nazw. ;
}
}
function auto() {
echo  Funkcja auto() z pola nazw. ;
}
}
$ford = new motoryzacja::samochod;
motoryzacja::auto();
?>
# wynik
Klasa samochód z pola nazw motoryzacja. Funkcja auto() z pola nazw motoryzacja.
Jak wida mo na dzi ki temu podzieli kod. Trzeba jednak uwa a bo mo na przesadzi i kod
stanie si ma o czytelny.
- 22 -
Zagnie d one pola nazw:
Pola nazw w PHP5 mo na zagnie d a . Pozwala to tworzy bardziej skomplikowane podzia y
kodu, co mo e pomóc w poprawieniu wygl du i wyrazisto ci. Przyk adowo pola nazw mo emy
zagnie d a w ten sposób:
# Przyk ad 19
namespace motoryzacja:klasy {
class samochod {
function __construct() {
echo  Klasa samochód z pola nazw motoryzacja:klasy. ;
}
}
}
namespace motoryzacja:funkcje {
function auto() {
echo  Funkcja auto() z pola nazw motoryzacja:funkcje. ;
}
}
$ford = new motoryzacja:klasy::samochod;
motoryzacja:funkcje::auto();
?>
# wynik
Klasa samochód z pola nazw motoryzacja:klasy. Funkcja auto() z pola nazw
motoryzacja:funkcje.
- 23 -
__autoload:
W PHP5 jest mo liwo zadeklarowania funkcji __autoload(), która b dzie automatycznie
adowa a potrzebne klasy. Dzi ki niej, mo emy podzieli klasy w oddzielne pliki, a do
programu zostan za adowane tylko te, które b d aktualnie potrzebne, pozwala to oszcz dzi
miejsce, pami i sprawi e w kodzie pomimo du ej zawarto ci wci b dzie panowa ad. W
praktyce wygl da to tak, na pocz tek definiujemy plik z klas :
# Przyk ad 20.1

class samochod
{
function prezentuj() {
echo  Prezentacja samochodu... ;
}
}
?>
Teraz plik ze skryptem i definicj __autoload():
# Przyk ad 20.2

function __autoload( $klasa ) {
include_once( $klasa .  .php );
}
$ford = new samochod;
$ford -> prezentuj();
?>
# wynik
Prezentacja samochodu...
Jak wida , skrypt sam za adowa potrzebn klas , dzi ki czemu zosta utworzony obiekt.
Dzi ki include_once mamy pewno e przy tworzeniu nast pnego egzemplarzu danej klasy
nie zostanie ona do czona ponowni. Pozwala to znacznie upro ci prac z wieloma klasami.
- 24 -
final:
W PHP5 zosta o wprowadzone s owo kluczowe final. Po poprzedzeniu metody tym s owem nie
b dzie mo liwe jej nadpisanie w klasach potomnych. Je eli zajdzie taka próba zostanie
wygenerowany b d. W przyk adzie wygl da to tak:
# Przyk ad 21
class silnik
{
final function silnikstart() {
echo  Silnik uruchomiony ;
}
}
?>
Teraz gdy jaka klasa odziedziczy klas silnik i b dzie zawiera a metod silnikstart() zostanie
wygenerowany b d. To samo tyczy si wszystkich klas potomnych.
- 25 -
Sta e:
W PHP5 zosta y wprowadzone sta e tzw. per-class, czyli sta e inicjalizowane za
po rednictwem klas. Wygl da to mniej wi cej tak:
# Przyk ad 22
class samochod
{
const MODEL =  mustang ;
}
echo  Model samochodu to:  . samochod::MODEL .  . ;
?>
# wynik
Model samochodu to: mustang.
PHP5 zezwala na stosowanie pewnych wyra e do inicjalizacji sta ych, ale przy wykorzystaniu
sta ych. Nie mo na definiowa sta ych których warto jest ustalana w trakcie kompilowania.
Mo na wi c zainicjalizowa jedne sta e sta ymi, a nast pnie inn sta wcze niej
zainicjalizowanymi sta ymi. W praktyce wygl da to tak:
# Przyk ad 23
class samochod
{
const MARKA =  Ford ;
const MODEL =  mustang ;
const SAMOCHOD = MARKA . " " . MODEL;
}
echo samochod::SAMOCHOD;
?>
# wynik
Ford mustang
- 26 -
Dereferencja obiektów:
W PHP4 zwracanie obiektu jako wyniku funkcji i bezpo rednie si do niego odwo anie nie by o
mo liwe. Takie dzia anie nazywa si dereferencja i w PHP5 jest mo liwe. Dzi ki temu mo na
wykorzysta funkcj aby u y obiektu wybranej klasy. W praktyce wygl da to tak:
# Przyk ad 24
class ford
{
function start() {
echo  Samochód ford uruchomiony. ;
}
}
class mercedes
{
function start() {
echo  Samochód mercedes uruchomiony. ;
}
}
function start( $samochod ) {
return new $samochod;
}
start( 'ford' ) -> start();
start( 'mercedes ) -> start();
?>
# wynik
Samochód ford uruchomiony.Samochód mercedes uruchomiony.
- 27 -
instanceof:
PHP4 wprowadza nowe s owo kluczowe "instanceof" dzi ki któremu mo emy sprawdzi czy
dany obiekt jest egzemplarzem danej klasy, czy jest jej potomkiem oraz czy zawiera
odpowiedni interfejs. W praktyce wygl da to tak:
# Przyk ad 25
interface auto
{
function parkoj();
}
class silnik
{
function start() {
echo  Silnik start. ;
}
}
class samochod extends silnik
implements auto
{
function parkoj() {
echo  Samochod zaparkowany. ;
}
}
$ford = new samochod;
if ( $ford instanceof samochod ) {
echo  Powi zanie z klas samochod. ;
}
if ( $ford instanceof silnik ) {
echo  Powi zanie z klas silnik. ;
}
if ( $ford instanceof auto ) {
echo  Powi zanie z interfejsem auto. ;
}
?>
# wynik
Powi zanie z klas samochod.Powi zanie z klas silnik.Powi zanie z interfejsem auto.
Mo na to wykorzysta do sprawdzania kodu oraz hierarchii klas, wykorzystuj c konstrukcje
warunkowe, tak jak to pokazano w przyk adzie.
- 28 -
Warto domy lna parametrów z referencj :
W PHP5 jest mo liwo ustawiania domy lnych warto ci dla parametrów funkcji które maj
by przekazane przez referencj . Wygl da to tak:
# Przyk ad 26
function samochod( &$marka = 'brak' ) {
if ( $marka == 'brak' ) {
die ( 'Podaj mark samochodu.' );
} else {
echo  Wszystko ok. ;
}
}
samochod();
?>
# wynik
Podaj mark samochodu.
Proste a zarazem bardzo praktyczne. Pami taj e przez referencj mo na poda tylko
zmienn .
- 29 -