Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00689 010469 11036952 na godz. na dobę w sumie
PHP i MySQL. Aplikacje bazodanowe - książka
PHP i MySQL. Aplikacje bazodanowe - książka
Autor: , Liczba stron: 792
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-671-3 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> bazy danych >> mysql - programowanie
Porównaj ceny (książka, ebook, audiobook).

Książka 'PHP i MySQL. Aplikacje bazodanowe' jest przeznaczona dla tych, którzy tworzą lub zamierzają tworzyć witryny WWW oparte na technologii PHP i MySQL. Opisano w niej reguły i techniki wykorzystywane przy tworzeniu małych i średnich aplikacji bazodanowych wykorzystywanych do przechowywania danych, odczytywania ich i zarządzania nimi. Przedstawia zasady pracy z bazami danych. Pokazuje, jak śledzić poczynania użytkowników za pomocą sesji, pisać bezpieczny kod, oddzielać go od warstwy prezentacyjnej i uniezależniać go od wyboru bazy danych. Opisuje również techniki generowania raportów i obsługi błędów oraz zaawansowane zagadnienia związane z bazami danych i programowaniem zorientowanym obiektowo.

Wiadomości zawarte w tej książce pomogą każdemu programiście stworzyć sklep internetowy, portal lub system zarządzania treścią.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl PHP i MySQL. Aplikacje bazodanowe Autorzy: Hugh E. Williams, David Lane T³umaczenie: Micha³ Dadan (rozdz. 1 – 8, 10), Pawe³ Gonera (rozdz. 9, 16 – 20, dod. A – H), Daniel Kaczmarek (rozdz. 11 – 15) ISBN: 83-7361-671-3 Tytu³ orygina³u: Web Database Applications with PHP and MySQL Format: B5, stron: 792 Ksi¹¿ka „PHP i MySQL. Aplikacje bazodanowe” jest przeznaczona dla tych, którzy tworz¹ lub zamierzaj¹ tworzyæ witryny WWW oparte na technologii PHP i MySQL. Opisano w niej regu³y i techniki wykorzystywane przy tworzeniu ma³ych i ġrednich aplikacji bazodanowych wykorzystywanych do przechowywania danych, odczytywania ich i zarz¹dzania nimi. Przedstawia zasady pracy z bazami danych. Pokazuje, jak ġledziæ poczynania u¿ytkowników za pomoc¹ sesji, pisaæ bezpieczny kod, oddzielaæ go od warstwy prezentacyjnej i uniezale¿niaæ go od wyboru bazy danych. Opisuje równie¿ techniki generowania raportów i obs³ugi b³êdów oraz zaawansowane zagadnienia zwi¹zane z bazami danych i programowaniem zorientowanym obiektowo. • Typowe modele architektury aplikacji bazodanowych • Jêzyk PHP — podstawowe wiadomoġci • Programowanie zorientowane obiektowo w PHP5 • Jêzyk SQL i baza danych MySQL • Biblioteka PEAR • Kontrola poprawnoġci wprowadzanych danych z wykorzystaniem PHP i JavaScript • Mechanizmy bezpieczeñstwa w aplikacjach bazodanowych • Wdra¿anie aplikacji • Generowanie raportów • Przyk³ad praktyczny — internetowy sklep z winami Wiadomoġci zawarte w tej ksi¹¿ce pomog¹ ka¿demu programiġcie stworzyæ sklep internetowy, portal lub system zarz¹dzania treġci¹. Spis treści Wstęp...................................................l...................................................l........................ 7 1. Aplikacje bazodanowe a Internet ...................................................l.............................17 18 19 Sieć WWW Architektury trójwarstwowe 2. Język skryptowy PHP ...................................................l................................................ 33 33 Wprowadzenie do PHP 45 Instrukcje rozgałęziające i wyrażenia warunkowe Pętle 49 52 Funkcje 53 Praca z typami 58 Funkcje definiowane przez użytkownika Praktyczny przykład 68 3. Tablice, łańcuchy i zaawansowane operacje na danych.............................................71 71 89 99 108 114 Tablice Łańcuchy Wyrażenia regularne Daty i godziny Liczby całkowite i zmiennopozycyjne 4. Wprowadzenie do programowania zorientowanego obiektowo w PHP 5 ............. 119 119 133 140 Klasy i obiekty Dziedziczenie Zgłaszanie i obsługiwanie wyjątków 5. SQL i MySQL ...................................................l...................................................l......... 143 143 149 151 157 161 169 176 Podstawy baz danych Interpreter poleceń MySQL Zarządzanie bazami danych i tabelami Wstawianie, uaktualnianie i usuwanie danych Zapytania z wyrażeniem SELECT Złączenia Praktyczny przykład: dodawanie nowego wina 3 6. Kierowanie zapytań do baz danych...................................................l........................179 180 195 214 Przesyłanie zapytań do baz MySQL z poziomu PHP Przetwarzanie informacji wprowadzanych przez użytkowników Opis funkcji biblioteki MySQL 7. PEAR...................................................l...................................................l...................... 225 225 226 236 Pierwsze spojrzenie Podstawowe składniki Pakiety 8. Umieszczanie danych w internetowych bazach danych.......................................... 257 257 275 Wstawianie, uaktualnianie i usuwanie informacji z baz danych Problemy z zapisywaniem informacji w bazach danych 9. Weryfikacja danych za pomocą PHP i języka JavaScript ...........................................291 291 294 311 Zasady kontroli poprawności i raportowania błędów Weryfikacja po stronie serwera za pomocą PHP JavaScript i kontrola poprawności po stronie klienta 10. Sesje ...................................................l...................................................l...................... 339 340 341 348 357 360 Wprowadzenie do zarządzania sesjami Zarządzanie sesjami w PHP Przykład praktyczny: stosowanie sesji przy weryfikacji danych Kiedy należy stosować sesje? API zarządzania sesjami i konfiguracja sesji 11. Uwierzytelnianie i bezpieczeństwo...................................................l........................371 371 375 386 398 Uwierzytelnianie HTTP Uwierzytelnianie HTTP w PHP Uwierzytelnianie na podstawie formularza Ochrona danych w sieci WWW 12. Błędy, debugowanie i wdrażanie...................................................l...........................403 403 408 413 Błędy Najczęstsze błędy programistyczne Własne mechanizmy obsługi błędów 13. Raporty ...................................................l...................................................l.................423 423 428 440 Tworzenie raportu Tworzenie dokumentu PDF Instrukcja PDF-PHP 4 | Spis treści 14. Zaawansowane programowanie obiektowe w PHP 5 ............................................. 457 457 461 462 467 Korzystanie z hierarchii klas Wskazanie typu klasy Klasy abstrakcyjne i interfejsy Przykład: kalkulator kosztów transportu 15. Zaawansowany SQL...................................................l................................................ 477 478 479 494 502 510 513 519 524 528 Analiza przy użyciu polecenia SHOW Zapytania zaawansowane Operacje na danych i bazach danych Funkcje Automatyzacja wykonywania zapytań Typy tabel Kopie zapasowe i ich odtwarzanie Zarządzanie użytkownikami i uprawnieniami Dostrajanie serwera MySQL 16. Sieciowa winiarnia „Hugh i Dave”. Analiza przypadku........................................... 539 540 542 547 Wymagania systemowe i funkcjonalne Omówienie aplikacji Komponenty współdzielone 17. Zarządzanie kontami klientów ...................................................l.............................. 575 576 579 582 Przegląd kodu Kontrola poprawności danych klienta Formularz klienta 18. Koszyk na zakupy...................................................l...................................................l. 587 588 589 594 Przegląd kodu Strona domowa sieciowej winiarni Implementacja koszyka 19. Zamawianie i wysyłka w sieciowej winiarni ...................................................l......... 607 607 609 612 618 Przegląd kodu Dane karty kredytowej i instrukcje wysyłki Realizacja zamówienia Potwierdzenia z poziomu strony HTML oraz przez e-mail 20. Wyszukiwanie i autoryzacja w sieciowej winiarni .................................................. 629 630 634 643 Przegląd kodu Przeglądanie i wyszukiwanie Autoryzacja Spis treści | 5 A Przewodnik instalacji w systemie Linux ...................................................l.................651 B Przewodnik instalacji w systemie Microsoft Windows.............................................671 C Przewodnik instalacji w systemie Mac OS X...................................................l.......... 681 D Protokoły sieciowe...................................................l.................................................. 697 E Modelowanie i projektowanie relacyjnych baz danych........................................... 709 F Zarządzanie sesjami w warstwie bazy danych ...................................................l..... 727 G Zasoby...................................................l...................................................l....................741 H Ulepszona biblioteka MySQL...................................................l.................................. 745 Skorowidz...................................................l...................................................l............. 757 6 | Spis treści ROZDZIAŁ 4. Wprowadzenie do programowania zorientowanego obiektowo w PHP 5 Idea programowania zorientowanego obiektowo ma już parę dziesięcioleci. Zyskała ona taką popularność, że obecnie stosuje się ją niemal we wszystkich językach programowania. Powody takiego stanu rzeczy łatwo zrozumieć gdy zacznie się wykorzystywać tak wygodne rozwiąza- nia, jak pakiety dodatkowych funkcji dla PHP. Jeden z nich, o nazwie PEAR, opisujemy w roz- dziale 7. Wiele z tych funkcji definiuje własne obiekty, dzięki którym cała ich funkcjonalność jest udostępniana w bardzo przystępnej formie. Aby móc korzystać z pakietów i z tak zwanych wyjątków, które ułatwiają obsługę błędów, trzeba poznać podstawy programowania zorien- towanego obiektowo. Możliwe, że czytelnik dojdzie nawet do wniosku, że będzie chciał wy- korzystywać obiekty w swoim własnym kodzie. Ten rozdział stanowi wprowadzenie w świat obiektów, a ich zaawansowane możliwości opisujemy w rozdziale 14. Założenia i techniki, o których tu piszemy, odnoszą się przede wszystkim do nowej, znacznie rozbudowanej wersji PHP 5. Wiele z nich w PHP 4 wygląda tak samo, ale nie wszystkie. Dlate- go w dalszej części rozdziału piszemy wyraźnie, co można zrobić w konkretnej wersji języka. Klasy i obiekty Główną ideą stojącą za programowaniem zorientowanym obiektowo jest to, że dane można umieścić razem z funkcjami w wygodnych pojemnikach zwanych obiektami. Na przykład w roz- dziale 7. powiemy jak można nadać kilku witrynom taki sam wygląd, korzystając z obiektu nazywanego szablonem (ang. template). W naszym kodzie PHP będziemy mogli odwoływać się do niego poprzez dowolną zmienną. Na potrzeby tego przykładu przyjmijmy, że nazwiemy ją $template. Wszystkie szczegóły implementacyjne poszczególnych szablonów są przed nami ukryte. Wystarczy jedynie, że wczytamy odpowiedni pakiet i umieścimy w kodzie PHP wyra- żenie tego typu: $template = new HTML_Template_IT( ./templates ); Jak sugeruje użycie operatora new (nowy), właśnie utworzyliśmy nowy obiekt. Będzie się on nazywał $template i został utworzony przez pakiet HTML_Template_IT, którego kodu wcale nie musimy znać! Mając obiekt $template możemy już korzystać z całej funkcjonalności ofe- rowanej przez pakiet HTML_Template_IT. 119 Po przeprowadzeniu wielu różnych operacji na tym obiekcie możemy wyświetlić go na stronie WWW za pomocą polecenia: $template- show(); Warto przyjrzeć się składni tego polecenia. Jak sugeruje użycie nawiasów, show() jest funkcją. Jest ona jednak powiązana za pomocą operatora - ze zmienną $template. Gdy funkcja show() zostanie wywołana, pobierze ona dane przechowywane w obiekcie $template i to na ich pod- stawie wyliczy wyniki. Innymi słowy, funkcja show() jest wywoływana na obiekcie $template. To, jakie funkcje wywołujemy, zależy od tego, jakie są dostępne w danym pakiecie. Na przy- kład pakiet HTML_Template_IT udostępnia funkcję show(), co oznacza, że można ją wywoły- wać na obiektach HTML_Template_IT takich jak $template. W tradycyjnym języku programo- wania zorientowanego obiektowo funkcję show() nazywamy metodą lub funkcją składową obiektu HTML_Template_IT. Mówimy, że HTML_Template_IT jest klasą, ponieważ możemy wykorzystać ją do utworzenia dowolnej liczby takich samych obiektów-szablonów. Tak więc obiekt $template jest obiektem 1. klasy HTML_Template_IT Wiadomo już więc, jak tworzyć obiekty klas zdefiniowanych w pakietach. Jednak, aby czy- telnik lepiej zrozumiał naturę obiektów, pokażemy teraz, jak można zdefiniować własną klasę. Na listingu 4.1 przedstawiamy prostą klasę wymyśloną na potrzeby tego rozdziału, o nazwie UnitCounter. Oferuje ona dwie banalne funkcje — można wykorzystywać ją do zliczania okre- ślonych przedmiotów oraz do wyliczenia ich sumarycznej masy. W dalszej części tego roz- działu, a także w rozdziale 14., będziemy wykorzystywali tę klasę w połączeniu z innymi kla- sami i utworzymy prosty kalkulator obliczający należność za przewóz towarów. Listing 4.1. Definicja nowej klasy UnitCounter ?php // Definicja klasy UnitCounter class UnitCounter { // Zmienne składowe var $units = 0; var $weightPerUnit = 1.0; // Dodaj $n do całkowitej liczby sztuk. Niech domyślną wartością $n będzie 1. function add($n = 1) { $this- units = $this- units + $n; } // Funkcja składowa obliczająca całkowitą masę function totalWeight() { return $this- units * $this- weightPerUnit; } } ? 1 Wyobraź sobie, że klasa to foremka do piasku, a obiekty to babki, które nią wyciskasz — przyp. tłum. 120 | Rozdział 4. Wprowadzenie do programowania zorientowanego obiektowo w PHP 5 Jak widać na listingu 4.1, klasę UnitCounter definiujemy posługując się słowem kluczowym class. Klasa ta ma dwie zmienne składowe — $units i $weightPerUnit i dwie funkcje składo- we — add() i totalWeight(). Łącznie wspomniane funkcje i zmienne nazywamy składowymi klasy UnitCounter. Definicja klasy określa, w jaki sposób określona funkcjonalność ma zostać powiązana z danymi. Funkcje i zmienne składowe nabierają znaczenia dopiero w kontekście klasy, której są czę- ścią. Definicja klasy pokazana na listingu 4.1 nie powoduje wykonania żadnych działań ani zwrócenia żadnych wyników. Zamiast tego tworzy ona nowy typ danych, z którego będzie można korzystać w skrypcie PHP. W praktyce możemy umieścić tę definicję klasy w zewnętrz- nym pliku, który będziemy dołączać do każdego skryptu, w którym będzie ona potrzebna. Aby móc odwoływać się do zmiennych i funkcji składowych zdefiniowanych w klasie, mu- simy utworzyć obiekt tej klasy. Podobnie jak dane innych typów, takich jak liczby całkowite, łań- cuchy czy tablice, obiekty można przypisywać do zmiennych. Jednak w przeciwieństwie do zmiennych innych typów, obiekty tworzy się za pomocą operatora new. Oto jak można utworzyć obiekt klasy UnitCounter i przypisać go do zmiennej: // Utwórz nowy obiekt UnitCounter $bottles = new UnitCounter; Inaczej niż w przypadku nazw zmiennych, PHP nie rozróżnia dużych i małych liter występują- cych w nazwach klas. Mimo iż my przyjęliśmy zasadę, aby zaczynać je wielką literą, tak na- prawdę UnitCounter, unitcounter i UNITCOUNTER to jedna i ta sama klasa. Po utworzeniu nowego obiektu UnitCounter i przypisaniu go do zmiennej $bottles możemy korzystać z jego funkcji i zmiennych składowych. Dostęp do składowych obiektu, zarówno funkcji jak i zmiennych, odbywa się poprzez operator - . Do zmiennej składowej $units mo- żemy odwołać się poprzez wyrażenie $bottles- units i traktować ją dokładnie tak samo jak każdą inną zmienną: // Ustaw licznik na dwa tuziny butelek $bottles- units = 24; // Wyświetl Są 24 sztuki print Są {$bottles- units} sztuki ; Chcąc umieścić wartość przechowywaną w zmiennej składowej obiektu wewnątrz łańcucha ujętego w cudzysłów, musimy użyć nawiasów klamrowych. Łańcuchy i nawiasy klamrowe omówiliśmy w rozdziale 2. Do operowania wartością zmiennej $bottles możemy użyć funkcji składowej add(), wywołu- jąc ją poprzez wyrażenie $bottles- add(). Poniższy fragment kodu zwiększa wartość prze- chowywaną w zmiennej $bottles- units o 3: // Dodaj trzy butelki $bottles- add(3); // Wyświetl Jest 27 sztuk print Jest {$bottles- units} sztuk ; Możemy utworzyć kilka obiektów tej samej klasy. Na przykład poniższy fragment kodu tworzy dwa obiekty UnitCounter i przypisuje je do dwóch różnych zmiennych: // Utwórz dwa obiekty UnitCounter $books = new UnitCounter; $cds = new UnitCounter; Klasy i obiekty | 121 // Dodaj po parę sztuk $books- add(7); $cds- add(10); // Wyświetl 7 książek i 10 płyt print {$books- units} książek i {$cds- units} płyt ; Obie zmienne, $books i $cd, odnoszą się do obiektów UnitCounter, ale każdy z tych obiek- tów jest niezależny od pozostałych. Zmienne składowe Zmienne składowe klas można deklarować zarówno w PHP 4, jak i w PHP 5. Ich definicje umieszcza się w definicjach klas i poprzedza się je słowem kluczowym var. W tym miejscu można też stosować słowa kluczowe private i protected, o których piszemy w dalszej części rozdziału. Zadaniem zmiennych składowych jest trzymanie danych przechowywanych w obiekcie. W definicji klasy można określić początkową wartość, jaką ma przyjąć dana zmienna składowa. Na przykład w klasie UnitCounter z listingu 4.1 zdefiniowaliśmy początkowe wartości obu zmiennych składowych: var $units = 0; var $weightPerUnit = 1.0; Słowo kluczowe var jest wymagane po to, aby zaznaczyć, że $units i $weightPerUnit to zmienne składowe klasy. Gdy tworzony jest nowy obiekt UnitCounter, jego zmienne $units i $weightPerUnit otrzymują wartość odpowiednio 0 i 1.0. Jeżeli w definicji klasy nie okre- ślono domyślnej wartości zmiennej, wówczas nie otrzymuje ona żadnej wartości. Jawne deklarowanie zmiennych składowych w taki sposób, w jaki zrobiliśmy to na listingu 4.1, nie jest obowiązkowe. Jednak zalecamy właśnie takie postępowanie — deklarowanie zmien- nych i nadawanie im wartości początkowych za każdym razem, ponieważ dzięki temu inni programiści, którzy będą wykorzystywali dany kod, będą od razu znali ich stan. Funkcje składowe Funkcje składowe klas można deklarować zarówno w PHP 4, jak i w PHP 5. Definicje funkcji składowych umieszcza się w definicjach klas. Klasa UnitCounter z listingu 4.1 ma dwie funkcje składowe — add() i totalWeight(). Obie te funkcje mogą odwoływać się do zmiennych składowych obiektu, na rzecz którego zostały wywołane, za pośrednictwem specjalnej zmiennej $this. Mówimy, że jest ona specjal- na, ponieważ PHP rezerwuje za jej pośrednictwem miejsce w pamięci, które czeka na pojawie- nie się obiektu, który dopiero zostanie utworzony. Gdy wywoływana jest któraś z funkcji skła- dowych, wartością tej zmiennej staje się obiekt, na rzecz którego ta funkcja jest wywoływana. Przyjrzyj się implementacji funkcji składowej add() klasy UnitCounter z listingu 4.1: // Dodaj $n do całkowitej liczby sztuk. Niech domyślną wartością $n będzie 1. function add($n = 1) { $this- units = $this- units + $n; } 122 | Rozdział 4. Wprowadzenie do programowania zorientowanego obiektowo w PHP 5 Funkcja ta dodaje wartość parametru $n do zmiennej składowej $this- units. Jeżeli nie zo- stanie przekazany żaden parametr, $n otrzyma domyślną wartość 1. Gdy funkcja add() zo- stanie w poniższym przykładzie wywołana na rzecz obiektu $bottles, // Utwórz nowy obiekt UnitCounter $bottles = new UnitCounter; // Wywołaj funkcję add() $bottles- add(3); zmienna $this w funkcji add() stanie się synonimem $bottles. Funkcja składowa totalWeight() również odwołuje się do zmiennych składowych za pomocą wyrażenia $this. Zwraca ona całkowitą masę produktów mnożąc przez siebie wartości zmien- nych składowych $this- units i $this- weightPerUnit. // Utwórz nowy obiekt UnitCounter $bricks = new UnitCounter; $bricks- add(15); // Wyświetla 15 – 15 sztuk po 1 kg każda print $bricks- totalWeight(); PHP 5 pozwala na umieszczanie wyników zwracanych przez funkcje składowe w łańcuchach. Trzeba w tym celu otoczyć je nawiasami klamrowymi, tak jak to pokazaliśmy poniżej. Pokazu- jemy też alternatywne rozwiązanie, które można stosować w PHP 4: // To polecenie działa tylko w PHP 5 print Całkowita masa = {$bottles- totalWeight()} kg ; // To polecenie działa zarówno w PHP 4, jak i w PHP 5 print Całkowita masa = . $bottles- totalWeight() . kg n; Umieszczanie definicji klas w osobnych plikach Umieszczając definicję z listingu 4.1 w osobnym pliku, dajmy na to UnitCounter.inc, zyskujemy możliwość dołączania jej do innych skryptów poprzez wywoływanie poleceń include i require. Na listingu 4.2 pokazaliśmy przykładową dyrektywę require dołączającą do bieżącego skryptu definicję klasy UnitCounter. Listing 4.2. Wykorzystywanie klasy UnitCounter !DOCTYPE HTML PUBLIC -//W3C//DTD HTML 4.01 Transitional//EN http://www.w3.org/TR/html401/loosne.dtd html head meta http-equiv= Content-Type content= text/html; cnharset=iso-8859-2 title Wykorzystywanie klasy UnitCounter /title /head body ?php require UnitCounter.inc ; // Utwórz nowy obiekt UnitCounter $bottles = new UnitCounter; // Ustaw licznik na 2 tuziny butelek $bottles- units = 24; Klasy i obiekty | 123 // Dodaj jedną butelkę $bottles- add(); // Dodaj jeszcze trzy $bottles- add(3); // Pokaż całkowitą liczbę butelek i ich masę print Jest {$bottles- units} sztuk, ; print całkowita masa = . $bottles- totalWeight() . kgn ; // Zmień domyślną masę jednej sztuki i pokaż nową masę całkowitą $bottles- weightPerUnit = 1.2; print br Prawidłowa masa całkowita = . $bottles- totalwenight() . kg ; ? /body /html Dyrektywy include i require przedstawiliśmy już w rozdziale 2. Dalsze przykłady ich wyko- rzystania zamieściliśmy w rozdziałach 6. i 16., w których opracowujemy biblioteki dla naszego sklepu internetowego Hugh i Dave. Konstruktory PHP 4 pozwala na definiowanie konstruktorów tylko w jeden sposób, a PHP 5 na dwa sposoby. Jak już wcześniej pisaliśmy, gdy tworzony jest obiekt klasy UnitCounter zdefiniowanej na listin- gu 4.1, PHP inicjalizuje jego zmienne składowe $units i $weightPerUnit wartościami 0 i 1.0. Jeżeli trzeba zmienić masę pojedynczego przedmiotu, można to zrobić już po utworzeniu obiektu, przypisując ją bezpośrednio do zmiennej składowej. Na przykład: // Utwórz nowy obiekt UnitCounter $bottles = new UnitCounter; // Ustaw rzeczywistą masę butelki $bottles- weightPerUnit = 1.2; Jednak lepszym rozwiązaniem jest utworzenie funkcji-konstruktora, która będzie dbała o to, aby obiekt został przed pierwszym użyciem doprowadzony do odpowiedniego stanu. Jeżeli zdefi- niujemy konstruktor, nie będziemy musieli inicjalizować niczego ręcznie, ponieważ PHP wy- woła go automatycznie w chwili tworzenia obiektu. PHP 5 pozwala na zadeklarowanie konstruktora w ciele definicji klasy poprzez umieszczenie w niej funkcji składowej o nazwie __construct() (słowo construct poprzedzone jest dwoma znakami podkreślenia). Na listingu 4.3 prezentujemy zmodyfikowaną klasę UnitCounter, roz- budowaną o konstruktor, który automatycznie ustawia prawidłową masę jednostkową. Listing 4.3. Definiowanie konstruktora dla klasy UnitCounter ?php class UnitCounter { var $units; var $weightPerUnit; function add($n = 1) { $this- units = $this- units + $n; } 124 | Rozdział 4. Wprowadzenie do programowania zorientowanego obiektowo w PHP 5 function totalWeight() { return $this- units * $this- weightPerUnit; } // Funkcja-konstruktor inicjalizująca zmienne składowe function __construct($unitWeight = 1.0) { $this- weightPerUnit = $unitWeight; $this- units = 0; } } ? Ta definicja klasy odpowiada definicji z listingu 4.1. Jednak początkowe wartości zmiennych $units i $weightPerUnit nie są już podawane w ich deklaracjach, lecz są im nadawane przez funkcję składową __construct(). Obiekty nowej klasy UnitCounter pokazanej na listingu 4.3 tworzy się w następujący sposób: // Utwórz obiekt UnitCounter, dla którego każdy przedmiot waży 1.2 kg // - tyle co pełna butelka wina. $bottles = new UnitCounter(1.2); W chwili tworzenia obiektu PHP automatycznie wywołuje funkcję __construct() z para- metrami podanymi po nazwie klasy. Tak więc w tym przykładzie do metody __construct() przekazywana jest wartość 1.2, która jest następnie przypisywana do zmiennej $bottles- weightPerUnit. W dalszym ciągu możliwe jest tworzenie obiektów UnitCounter bez przekazywania wartości do konstruktora, ponieważ dla zmiennej $unitWeight została zdefiniowana wartość domyśl- na równa 1.0. W PHP 5 można też zadeklarować konstruktor w inny sposób, a mianowicie definiując funkcję o takiej samej nazwie jak nazwa klasy. W PHP 4 była to jedyna dostępna metoda. Oznacza to, że na przykład na listingu 4.3 funkcję __construct() możemy zastąpić następującą funkcją: function UnitCounter($weightPerUnit = 1) { $this- weightPerUnit = $weightPerUnit; $this- units = 0; } Stosowanie funkcji o nazwie __construct() ułatwia zarządzanie dużymi projektami, ponieważ pozwala na łatwe przenoszenie klas, zmienianie ich nazw i wielokrotne wykorzystywanie ich w hierarchii klas bez konieczności modyfikowania ich zawartości. Hierarchie klas omówimy sobie w rozdziale 14. Destruktory Destruktory są dostępne jedynie w PHP 5. Jeżeli w danej klasie został zdefiniowany konstruktor, zostanie on wywołany w chwili, gdy będzie tworzony jakiś obiekt tej klasy. Na podobnej zasadzie działają destruktory — są one wywoływane, gdy obiekt jest usuwany z pamięci. Podobnie jak inne zmienne w PHP, obiekty są usuwane z chwilą gdy zostają poza zasięgiem lub gdy zostanie jawnie wywołana funkcja unset() (o zasięgu zmiennych pisaliśmy w rozdziale 2.). Klasy i obiekty | 125 Definiowanie destruktora polega na umieszczeniu w definicji klasy funkcji __destruct() (po- dobnie jak w przypadku konstruktorów, słowo kluczowe destruct poprzedzone jest dwoma podkreślnikami, a __destruct() to nazwa zastrzeżona, której nie można stosować dla żadnych innych funkcji). Funkcje __destruct() nie mogą pobierać żadnych argumentów (w przeciwień- stwie do funkcji __construct()), jednak mają one dostęp do zmiennych składowych usuwa- nych obiektów. PHP wywołuje destruktor tuż przed usunięciem składowych z pamięci. Destruktory przydają się wtedy, gdy przed usunięciem obiektu z pamięci chcemy wykonać jesz- cze jakieś czynności porządkowe. Możemy, na przykład, chcieć w elegancki sposób zamknąć połączenie z SZBD lub zapisać ustawienia wprowadzone przez użytkownika do pliku. Podczas tworzenia aplikacji zorientowanych obiektowo destruktory przydają się też przy diagnozowa- niu błędów. Na przykład dodanie funkcji __destruct() do klasy UnitCounter zdefiniowanej na listingu 4.3 pozwala zorientować się, kiedy następuje usuwanie obiektów: // Funkcja-destruktor wywoływana tuż przed usunięciem // obiektu UnitCounter z pamięci function __destruct() { print UnitCounter poza zasięgiem. Sztuk: {$this- units} ; } Inny przykład destruktora pokażemy w podrozdziale „Statyczne zmienne składowe”. Prywatne zmienne składowe Prywatne zmienne składowe można stosować w PHP 5. Każdy skrypt korzystający z obiektów klasy UnitCounter zdefiniowanej na listingu 4.3 może bezpośrednio odwoływać się do ich zmiennych składowych $units i $weightPerUnit, po- nieważ w klasie UnitCounter nie zaimplementowaliśmy żadnych mechanizmów, które zabez- pieczałyby nas przed przekazywaniem do obiektów nieprawidłowych wartości. Przyjrzyj się na przykład następującemu fragmentowi kodu, w którym nie dość, że liczba sztuk zostaje wy- rażona ułamkiem, to jeszcze masa jednostkowa otrzymuje ujemną wartość: // Utwórz nowy obiekt UnitCounter $b = new UnitCounter; // Ustaw pewne wartości $b- units = 7.3; $b- weightPerUnit = -5.5; $b- add(10); // Pokaż całkowitą liczbę sztuk i masę print Jest {$b- units} sztuk, ; print masa całkowita = {$b- totalWeight()} kg ; Ten kod powoduje wyświetlenie następującej informacji: Jest 17.3 sztuk, masa całkowita = -95.15 kg W PHP 5 znacznie lepszym rozwiązaniem od tego, które stosowaliśmy dotychczas, jest zade- klarowanie zmiennych składowych jako prywatnych i zdefiniowanie funkcji składowych, za po- średnictwem których będzie można się do nich odwoływać. Na listingu 4.4 zmienne $units i $weightPerUnit zostały zadeklarowane właśnie jako prywatne. 126 | Rozdział 4. Wprowadzenie do programowania zorientowanego obiektowo w PHP 5 Listing 4.4. Prywatne zmienne składowe ?php class UnitCounter { private $units = 0; private $weightPerUnit = 1.0; function numberOfUnits() { return $this- units; } function add($n = 1) { if (is_int($n) $n 0) $this- units = $this- units + $n; } function totalWeight() { return $this- units * $this- weightPerUnit; } function __construct($unitWeight) { $this- weightPerUnit = abs((float)$unitWeight); $this- units = 0; } } ? Po utworzeniu obiektu klasy UnitCounter zdefiniowanej na listingu 4.4, do zmiennych skła- dowych $units i $weightPerUnit można się dostać jedynie za pośrednictwem funkcji zdefi- niowanych w ciele klasy. Próba odwołania się do nich w tradycyjny sposób powoduje wystą- pienie błędu: // Utwórz obiekt klasy UnitCounter zdefiniowanej na listingu 4.4 $b = new UnitCounter(1.1); // Te polecenia powodują wystąpienie błędu $b- units = 7.3; $b- weightPerUnit = -5.5; Funkcja składowa numberOfUnits() daje dostęp do zmiennej $units, a funkcja składowa add() została ulepszona w taki sposób, aby całkowita liczba sztuk mogła być powiększana jedynie o całkowite wartości dodatnie. Ulepszyliśmy też funkcję __construct(), tak aby gwarantowała ona, że do zmiennej $weightPerUnit zostanie przypisana wartość dodatnia. Definiowanie funkcji składowych pozwalających kontrolować sposób, w jaki są wykorzysty- wane zmienne składowe jest dobrą praktyką programistyczną. Jednak stosowanie takich środ- ków ostrożności na niewiele się przyda, jeżeli nie uczynimy zmiennych składowych prywat- nymi. Po prostu do tak zwanych publicznych zmiennych składowych można się odwoływać bezpośrednio i w prosty sposób zmieniać ich wartość. Prywatne funkcje składowe Prywatne funkcje składowe można stosować w PHP 5. Klasy i obiekty | 127 Jako prywatne można też zadeklarować funkcje składowe. Pozwala to ukryć szczegóły imple- mentacyjne klasy, a to z kolei umożliwia modyfikowanie klasy w sposób, który nie wymaga późniejszej zmiany skryptów, w których jest ona wykorzystywana. Na listingu 4.5 pokazaliśmy, w jaki sposób klasa FreightCalculator ukrywa wewnętrzne metody wykorzystywane przez publicznie dostępną funkcję składową totalFreight(). Funkcja ta oblicza koszty przewozu to- waru posiłkując się dwiema prywatnymi metodami — perCaseTotal() i perKgTotal(). Listing 4.5. Prywatne funkcje składowe class FreightCalculator { private $numberOfCases; private $totalWeight; function totalFreight() { return $this- perCaseTotal() + $this- perKgTotal(); } private function perCaseTotal() { return $this- numberOfCases * 1.00; } private function perKgTotal() { return $this- totalWeight * 0.10; } function __construct($numberOfCases, $totalWeight) { $this- numberOfCases = $numberOfCases; $this- totalWeight = $totalWeight; } } Podobnie jak do prywatnych zmiennych składowych, do prywatnych funkcji składowych moż- na się dostać jedynie z wnętrza klasy, w której je zdefiniowano. Poniższy fragment kodu po- woduje wystąpienie błędu: // Utwórz obiekt klasy FreightCalculator zdefiniowanej na listingu 4.5 $f = new FreightCalculator(10, 150); // Te polecenia powodują wystąpienie błędu print $f- perCaseTotal(); print $f- perKgTotal(); // To polecenie jest OK — wyświetla wartość 25 print $f- totalFreight(); Statyczne zmienne składowe Statyczne zmienne składowe można stosować w PHP 5. PHP pozwala na deklarowanie zmiennych i funkcji składowych jako statycznych. Służy do tego słowo kluczowe static. Jak widziałeś w dotychczasowych przykładach, każdy obiekt danej kla- sy ma swoją własną, niezależną kopię zmiennych składowych. Jednak w przypadku składowych 128 | Rozdział 4. Wprowadzenie do programowania zorientowanego obiektowo w PHP 5 statycznych jest inaczej. Są one współdzielone przez wszystkie obiekty danej klasy. Dzięki nim możemy wykorzystywać we wszystkich obiektach klasy te same wartości, bez konieczności deklarowania zmiennej globalnej, która byłaby dostępna w całym skrypcie. Na listingu 4.6 definiujemy klasę Donation (darowizna). W każdym jej obiekcie będziemy przechowywali nazwisko ofiarodawcy i informację o kwocie, jaką zdecydował się przekazać — odpowiednio w zmiennej $name i $amount. Klasa ta będzie też śledziła całkowitą ilość zebra- nych pieniędzy i całkowitą liczbę zebranych datków. Wartości te będą przechowywane w zmien- nych $totalDonated i $numberOfDonors, które będą dostępne dla wszystkich obiektów kla- sy. Każdy z nich będzie mógł odczytywać i zmieniać ich wartości. Do statycznych zmiennych składowych odwołujemy się przez referencję do klasy, a nie przez operator - . Dlatego na li- stingu 4.6 zmienne statyczne $totalDonated i $numberOfDonors są poprzedzone nazwą klasy (Donation::). Listing 4.6. Statyczne zmienne składowe ?php class Donation { private $name; private $amount; static $totalDonated = 0; static $numberOfDonors = 0; function info() { $share = 100 * $this- amount / Donation::$totalDonatedn; return {$this- name} podarował {$this- amount} ({$sharen} ) ; } function __construct($nameOfDonor, $donation) { $this- name = $nameOfDonor; $this- amount = $donation; Donation::$totalDonated = Donation::$totalDonated + $donnation; Donation::$numberOfDonors++; } function __destruct() { Donation::$totalDonated = Donation::$totalDonated - $dnonation; Donation::$numberOfDonors--; } } ? !DOCTYPE HTML PUBLIC -//W3C//DTD HTML 4.01 Transitional//EN http://www.w3.org/TR/html40l/loosne.dtd html head meta http-equiv= Content-Type content= text/html; cnharset=iso-8859-2 title Korzystanie z klasy Donation /title /head body pre Klasy i obiekty | 129 ?php $donors = array( new Donation( Mikołaj , 85.00), new Donation( Bartłomiej , 50.00), new Donation( Tymoteusz , 90.00), new Donation( Grzegorz , 65.00)); foreach ($donors as $donor) print $donor- info() . ; $total = Donation::$totalDonated; $count = Donation::$numberOfDonors; print Suma darowizn = {$total} ; print Liczba ofiarodawców = {$count} ; ? /pre /body /html Wartości zmiennych statycznych $totalDonated i $numberOfDonors są uaktualniane w funk- cji __construct(). Wartość $donation jest dodawana do wartości $totalDonated, a zmienna $numberOfDonors jest inkrementowana. Zdefiniowaliśmy też funkcję __destruct(), która de- krementuje zmienne $totalDonated i $numberOfDonors w chwili, gdy jakiś obiekt klasy Dona- tion jest usuwany z pamięci. Kod pokazany na listingu 4.6 definiuje najpierw klasę Donation, a następnie tworzy tablicę obiektów i wyświetla informację o liczbie darowizn i o całkowitej zebranej kwocie: $total = Donation::$totalDonated; $count = Donation::$numberOfDonors; print Suma darowizn = {$total} ; print Liczba ofiarodawców = {$count} ; Ten fragment kodu pokazuje, że do statycznych zmiennych składowych można się odwoły- wać również spoza klasy, o ile tylko poprzedzi się ich nazwy przedrostkiem Donation::. Do zmiennych tych nie odwołujemy się za pomocą operatora - (stosowanego wraz z nazwą obiek- tu), ponieważ nie są one związane z żadnym konkretnym obiektem. W celu wyświetlenia informacji o wszystkich darowiznach zastosowaliśmy pętlę foreach, w której dla każdego obiektu Donation wywołujemy funkcję składową info(). Zwraca ona łańcuch zawierający nazwisko ofiarodawcy, informację o przekazanej przez niego kwocie i o tym, jak duży (procentowo) jest jego wkład. Ta ostatnia wartość jest obliczana poprzez podzielenie wartości przechowywanej w zmiennej $this- amount danego obiektu przez statyczną wartość Donation::$totalDonated. Wyniki zwracane przez kod z listingu 4.6 wyglądają następująco: Mikołaj podarował 85 (29.3103448276 ) Bartłomiej podarował 50 (17.2413793103 ) Tymoteusz podarował 90 (31.0344827586 ) Grzegorz podarował 65 (22.4137931034 ) Suma darowizn = 290 Liczba ofiarodawców = 4 W przeciwieństwie do innych zmiennych składowych, ze zmiennych statycznych można ko- rzystać nawet wtedy, gdy nie ma jeszcze żadnego obiektu danej klasy. Jeżeli tylko skrypt ma dostęp do definicji klasy, możesz odwoływać się do zmiennych statycznych poprzedzając ich nazwy specyfikatorem klasy, tak jak w poniższym przykładzie: 130 | Rozdział 4. Wprowadzenie do programowania zorientowanego obiektowo w PHP 5 // Uzyskaj dostęp do definicji klasy Donation require example.4-6.php ; // Teraz nadaj zmiennym statycznym żądane wartości Donation::$totalDonated = 124; Donation::$numberOfDonors = 5; Statyczne funkcje składowe Statyczne funkcje składowe można stosować w PHP 5. Deklaruje się je z użyciem słowa kluczowego static i podobnie jak w przypadku statycznych zmiennych składowych, odwołuje się do nich nie poprzez konkretne obiekty, lecz przez całą klasę, której nazwę umieszcza się przed nazwą funkcji. Możemy zmodyfikować listing 4.6 w taki sposób, aby dostęp do statycznych zmiennych składowych mógł odbywać się za pośrednictwem statycznych funkcji składowych: private static $totalDonated = 0; private static $numberOfDonors = 0; static function total() { return Donation::$totalDonated; } static function numberOfDonors() { return Donation::$numberOfDonors; } Kod wykorzystujący zmodyfikowaną wersję klasy Donation będzie teraz mógł uzyskiwać do- stęp do wartości zmiennych $totalDonated i $numberOfDonors za pośrednictwem statycznych funkcji Donation::total() i Donation::numberOfDonors(). Funkcje statyczne mogą operować jedynie na statycznych zmiennych składowych i nie mogą wykonywać żadnych operacji na obiektach. Właśnie dlatego w ich ciele nie może się nigdy znaleźć odwołanie do zmiennej $this. Podobnie jak do statycznych zmiennych składowych, do statycznych funkcji składowych moż- na się odwoływać bez konieczności tworzenia obiektów danej klasy. Oczywiście statyczne zmienne i funkcje składowe z listingu 4.6 mogliśmy zadeklarować jako zmienne globalne i zwy- kłe funkcje zdefiniowane przez użytkownika. Jednak zdefiniowanie ich jako statycznych ułatwia grupowanie elementów o zbliżonym działaniu w definicjach klas, co jest zgodne z modułowym podejściem do tworzenia kodu. Klonowanie obiektów. W PHP 4 obiekty są klonowane zawsze, a w PHP 5 jest to opcjonalne. W następnym podroz- dziale wyjaśnimy o co chodzi. Klonowanie w PHP 5 Gdy tworzony jest nowy obiekt, PHP 5 zwraca referencję do niego, a nie sam obiekt. Tak więc zmienna, do której przypisujemy obiekt, jest tak naprawdę referencją do obiektu. Jest to istotna różnica w stosunku do tego, co było w PHP 4, kiedy to do zmiennych były przypisywane Klasy i obiekty | 131 fizyczne obiekty. Utworzenie kopii zmiennej obiektowej w PHP 5 powoduje po prostu utwo- rzenie drugiej referencji do tego samego obiektu. Można to zaobserwować na przykładzie po- niższego fragmentu kodu, który tworzy nowy obiekt klasy UnitCounter zdefiniowanej na li- stingu 4.1: // Utwórz obiekt UnitCounter $a = new UnitCounter(); $a- add(5); $b = $a; $b- add(5); // Wyświetli Liczba sztuk = 10 ; print Liczba sztuk = {$a- units} ; Gdy chcemy utworzyć nową, niezależną kopię jakiegoś obiektu, musimy użyć metody __clone(). PHP 5 udostępnia domyślną postać tej metody, która tworzy nowy, identyczny obiekt i kopiuje wartości poszczególnych składowych. Weźmy pod uwagę poniższy fragment kodu: // Utwórz obiekt UnitCounter $a = new UnitCounter(); $a- add(5); $b = $a- __clone(); $b- add(5); // Wyświetli Liczba sztuk = 5 print Liczba sztuk = {$a- units} ; // Wyświetli Liczba sztuk = 10 print Liczba sztuk = {$b- units} ; Kod ten tworzy obiekt $a i dodaje do niego pięć sztuk towaru za pośrednictwem polecenia $a- add(5). W rezultacie w obiekcie $a znajduje się dokładnie 5 sztuk towaru. Następnie obiekt $a jest klonowany, a klon jest przypisywany do nowego obiektu $b. Potem do nowego obiektu $b dodawane jest 5 sztuk towaru, w wyniku czego w obiekcie tym znajduje się osta- tecznie 10 sztuk towaru. Po wyświetleniu liczby towarów przechowywanych w oryginalnym obiekcie $a okazuje się, że faktycznie jest ich 5, a w obiekcie $b, że jest ich 10. Możemy wpływać na sposób kopiowania obiektów umieszczając w definicjach naszych klas własną funkcję __clone().Gdybyśmy, na przykład, chcieli, aby sklonowany obiekt Unit- Counter przechowywał w zmiennej $weightPerUnit taką samą wartość jak oryginał, ale żeby wartość zmiennej $units została wyzerowana, moglibyśmy umieścić w definicji klasy nastę- pującą funkcję: function __clone() { $this- weightPerUnit = $that- weightPerUnit; $this- units = 0; } Do oryginalnego, źródłowego obiektu odwołujemy się w funkcji __clone() poprzez specjalną zmienną $that, a zmienna $this służy do odwoływania się do nowego obiektu, czyli do klonu. Klonowanie w PHP 4 PHP 4 nie stosuje domyślnie referencji. Wszystkie nowotworzone obiekty są bezpośrednio przy- pisywane do zmiennych. Gdy zmienna obiektowa jest kopiowana, PHP 4 automatycznie klo- nuje obiekt. Rozważmy na przykład następujący fragment kodu w PHP 4: 132 | Rozdział 4. Wprowadzenie do programowania zorientowanego obiektowo w PHP 5 // Utwórz obiekt UnitCounter $a = new UnitCounter(); $a- add(5); $b = $a; $b- add(5); // Wyświetli Liczba sztuk = 5 print Liczba sztuk = {$a- units} ; // Wyświetli Liczba sztuk = 10 print Liczba sztuk = {$b- units} ; Zmienna $b jest klonem (kopią) zmiennej $a, w związku z czym modyfikowanie jej nie wpływa w żaden sposób na zmienną $a. Jeżeli nie chcemy klonować obiektu, możemy użyć przypisania referencyjnego = , dzięki któ- remu zostanie skopiowana sama referencja. W poniższym fragmencie kodu zmienna $b jest przypisywana do zmiennej $a jako referencja do obiektu UnitCounter: // Utwórz obiekt UnitCounter $a = new UnitCounter(); $a- add(5); $b = $a; $b- add(5); // Wyświetli Liczba sztuk = 10 print Liczba sztuk = {$a- units} ; // Wyświetli Liczba sztuk = 10 print Liczba sztuk = {$b- units} ; Referencje i operator przypisania referencyjnego = omówiliśmy już w rozdziale 2. Dziedziczenie Dziedziczenie jest dostępne w PHP 4 i PHP 5. Jednym ze wspaniałych rozwiązań dostępnych w programowaniu zorientowanym obiektowo jest dziedziczenie. Pozwala ono na definiowanie nowych klas poprzez rozszerzanie możliwości klas już istniejących, nazywanych w tym przypadku klasami bazowymi lub inaczej podstawo- wymi. W PHP tworzenie nowych klas poprzez rozszerzanie istniejących wymaga stosowania słowa kluczowego extends. Na listingu 4.7 rozszerzamy klasę UnitCounter z listingu 4.4 tworząc nową klasę CaseCounter. Jej zadaniem będzie zliczanie opakowań potrzebnych do przechowywania przedmiotów, któ- rych liczbę nadzoruje klasa UnitCounter. Jeżeli, na przykład, tymi przedmiotami będą butelki wina, to każda skrzynka będzie mogła pomieścić ich 12. Listing 4.7. Definiowanie klasy CaseCounter poprzez rozszerzanie klasy UnitCounter ?php // Dostęp do definicji klasy UnitCounter require example.4-4.php ; class CaseCounter extends UnitCounter { var $unitsPerCase; Dziedziczenie | 133 function addCase() { $this- add($this- unitsPerCase); } function caseCount() { return ceil($this- units/$this- unitsPerCase); } function CaseCounter($caseCapacity) { $this- unitsPerCase = $caseCapacity; } } ? Zanim omówimy implementację klasy CaseCounter, powinniśmy przyjrzeć się jej związkowi z klasą UnitCounter. Na rysunku 4.1 został on przedstawiony w postaci prostego diagramu klas. Tego rodzaju diagramy można tworzyć na bardzo wiele sposobów. My zdecydowaliśmy się pokazać relację dziedziczenia łącząc dwie klasy strzałką. Rysunek 4.1. Diagram klas ukazujący zależność między klasami UnitCounter i CaseCounter Nowa klasa CaseCounter oferuje możliwość zliczania opakowań, w których znajduje się pewna liczba przedmiotów jednego typu — na przykład butelek wina. Natomiast klasa bazowa Unit- Counter oferuje możliwość zliczania przedmiotów i wyliczania ich całkowitej masy. Aby utworzyć obiekt CaseCounter musimy określić, ile przedmiotów można przechowywać w jednym opakowaniu. Wartość ta zostanie przekazana do konstruktora tworzonego obiektu: // Utwórz obiekt CaseCounter umieszczający po 12 butelek w skrzynce $order = new CaseCounter(12); a następnie zapamiętana w zmiennej składowej $unitsPerCase. Funkcja składowa addCase() wykorzystuje przy zliczaniu opakowań zmienną składową $units- PerCase: function addCase() { // Funkcja add() została już zdefiniowana // w klasie bazowej UnitCounter $this- add($this- unitsPerCase); } Dodawanie poszczególnych przedmiotów odbywa się poprzez wywoływanie funkcji składowej add() klasy bazowej UnitCounter. Wszystkie zmienne i funkcje składowe, które nie zostały zadeklarowane w klasie bazowej jako prywatne, mogą być wywoływane w klasach potomnych. Można się do nich odwoływać za pomocą operatora - i specjalnej zmiennej $this. 134 | Rozdział 4. Wprowadzenie do programowania zorientowanego obiektowo w PHP 5 Funkcja składowa caseCount() oblicza, ile opakowań potrzeba do zapakowania całkowitej liczby przedmiotów. Jeżeli na przykład mamy 50 butelek wina, a w każdej skrzynce mieści się 12, to potrzebujemy 5 skrzynek. Liczba skrzynek jest więc ustalana poprzez podzielenie całkowitej liczby przedmiotów (przechowywanej w zmiennej składowej $units zadeklaro- wanej w klasie UnitCounter) przez wartość przechowywaną w zmiennej składowej $unitsPer- Case. Wynik tej operacji jest zaokrąglany w górę do pełnej skrzynki za pomocą funkcji ceil(). Opisywaliśmy ją w rozdziale 3. Po utworzeniu nowego obiektu CaseCounter będzie można się w nim odwoływać do wszyst- kich publicznie dostępnych zmiennych i funkcji klasy bazowej. Oznacza to, że możemy ko- rzystać z obiektu CaseCounter dokładnie tak samo, jak gdyby był to obiekt UnitCounter, tyle że rozbudowany o nowe możliwości wprowadzone w klasie CaseCounter. Przyjrzyjmy się następującemu przykładowi: // Utwórz obiekt CaseCounter przechowujący po 12 butelek w skrzynce $order = new CaseCounter(l2); // Dodaj siedem butelek korzystając z funkcji zdefiniowanej w klasie UnitCounter $order- add(7); // Dodaj skrzynkę korzystając z funkcji zdefiniowanej w klasie CaseCounter $order- addCase(); // Wyświetl całkowitą liczbę przedmiotów : 19 print $order- units; // Wyświetl całkowitą liczbę skrzyń: 2 print $order- caseCount(); W przeciwieństwie do niektórych innych języków programowania, PHP pozwala definiować nowe klasy tylko na podstawie jednej klasy bazowej. Dziedziczenie z wielu klas bazowych mo- głoby tylko niepotrzebnie skomplikować kod, a poza tym nie jest ono zbyt przydatne w prakty- ce. W rozdziale 14. opiszemy zaawansowane techniki programistyczne, które eliminują potrzebę stosowania dziedziczenia tego typu. Wywoływanie konstruktorów klas podstawowych Możliwość wywoływania konstruktorów klas podstawowych jest dostępna w PHP 5. Obiekty CaseCounter wykorzystują trzy zmienne składowe. Dwie z nich są zdefiniowane w kla- sie UnitCounter, a jedna w klasie CaseCounter. Gdy tworzony jest obiekt klasy CaseCounter, PHP wywołuje funkcję __construct() zdefiniowaną w klasie CaseCounter i przypisuje zmien- nej składowej $unitsPerCase wartość przekazaną w parametrze. W poniższym fragmencie kodu do funkcji __construct() przekazywana jest wartość 12: // Utwórz obiekt CaseCounter przechowujący po 12 butelek w skrzynce $order = new CaseCounter(12); PHP wywołuje jedynie funkcję __construct() zdefiniowaną w klasie CaseCounter. Konstruk- tor klasy bazowej UnitCounter nie jest automatycznie wywoływany. Dlatego też obiekty klasy CaseCounter z listingu 4.7 mają zaraz po utworzeniu zadeklarowaną masę przedmiotu rów- ną 1 kg. Właśnie taką wartość ma bowiem zmienna składowa klasy bazowej. W klasie Case- Counter pokazanej na listingu 4.8 problem ten rozwiązano definiując funkcję __construct(), która wywołuje konstruktor klasy UnitCounter, odwołując się do niej za pośrednictwem wy- rażenia parent::. Dziedziczenie | 135 Listing 4.8. Wywoływanie konstruktora klasy bazowej ?php // Uzyskaj dostęp do definicji klasy UnitCounter include example.4-4.php ; class CaseCounter extends UnitCounter { private $unitsPerCase; function addCase() { $this- add($this- unitsPerCase); } function caseCount() { return ceil($this- units/$this- unitsPerCase); } function __construct($caseCapacity, $unitWeight) { parent::__construct($unitWeight); $this- unitsPerCase = $caseCapacity; } } ? Kod przedstawiony na listingu 4.8 wykorzystuje możliwości, jakie daje PHP 5. Rozszerzamy w nim bardziej zaawansowaną wersję klasy UnitCounter, z listingu 4.4. Zmienna składowa $unitsPerCase jest teraz zadeklarowana jako prywatna. Poza tym wykorzystujemy funkcję __construct() dostępną w PHP 5. Funkcja-konstruktor ulepszonej klasy CaseCounter poka- zanej na listingu 4.8 pobiera teraz także drugi parametr, $unit_Weight, który jest przekazy- wany do funkcji __construct() zdefiniowanej w klasie UnitCounter. Redefiniowanie funkcji Redefiniowanie funkcji można stosować zarówno w PHP 4, jak i w PHP 5, a w PHP 5 dodat- kowo jest dostępny operator parent:: i operatory referencji do klas. Redefiniowanie funkcji polega na ponownym zdefiniowaniu w klasie pochodnej funkcji do- stępnych w klasie bazowej. Po utworzeniu obiektów klasy pochodnej redefiniowane funkcje mają w nich wyższy priorytet niż funkcje zdefiniowane w klasie bazowej. Z redefiniowaniem funkcji spotkaliśmy się już na listingu 4.8, na którym funkcja __construct() klasy bazowej UnitCounter została ponownie zdefiniowana w klasie CaseCounter. Przyjrzyjmy się klasom Shape (kształt) i Polygon (wielokąt) zdefiniowanym w poniższym frag- mencie kodu: class Shape { function info() { return Shape. ; } } 136 | Rozdział 4. Wprowadzenie do programowania zorientowanego obiektowo w PHP 5 class Polygon extends Shape { function info() { return Polygon. ; } } Klasa Shape jest klasą bazową klasy Polygon, a tym samym klasa Polygon jest potomkiem klasy Shape. W obu klasach zdefiniowana jest funkcja info(). Zgodnie z podaną wcześniej regułą, gdy zostanie utworzony obiekt klasy Polygon, wszystkie wywołania funkcji info() będą doty- czyły funkcji zdefiniowanej w klasie Polygon. Można się o tym przekonać wykonując następujący fragment kodu: $a = new Shape; $b = new Polygon; // Wyświetla Shape. print $a- info(); // Wyświetla Polygon. print $b- info(); PHP 5 daje nam możliwość odwoływania się do funkcji info() z klasy bazowej — musimy poprzedzić jej nazwę wyrażeniem parent::. Możemy na przykład zmodyfikować definicję funkcji info() klasy Polygon w następujący sposób: class Polygon extends Shape { function info() { return parent::info() . Polygon. ; } } $b = new Polygon; // Wyświetla Shape.Polygon. print $b- info(); Takie rozwiązanie można stosować też w klasach pochodnych. Dzięki niemu funkcje klas po- chodnych zyskują cechy wszystkich funkcji o takiej samej nazwie zdefiniowanych w klasach nadrzędnych. Weźmy pod uwagę klasę Triangle (trójkąt), która rozszerza klasę Polygon: class Triangle extends Polygon { function info() { return parent::info() . Triangle. ; } } $t = new Triangle; // Wyświetl Shape.Polygon.Triangle. print $t- info(); Za pomocą operatora parent:: możemy dostać się jedynie do funkcji zdefiniowanej w klasie, z której bezpośrednio dziedziczymy. PHP daje też możliwość korzystania z funkcji zdefinio- wanych w dowolnej klasie nadrzędnej naszej klasy — za pośrednictwem operatora referencji do klasy, który poznałeś już przy okazji omawiania statycznych zmiennych i funkcji składowych Dziedziczenie | 137 w podrozdziale „Klasy i obiekty”. Możemy przepisać klasę Triangle w taki sposób, aby wy- woływała ona bezpośrednio funkcję info() zdefiniowaną w jej przodku (to znaczy w klasie nadrzędnej): class Triangle extends Polygon { function info() { return Shape::info() . Polygon::info() . Triangle. ; } } $t = new Triangle; // Wyświetla Shape.Polygon.Triangle. print $t- info(); Stosowanie operatorów dostępu do klasy czyni kod mniej przenośnym. Jeżeli, na przykład, pod- jęlibyśmy decyzję, że klasa Triangle powinna jednak być bezpośrednim potomkiem klasy Shape, musielibyśmy zmodyfikować jej implementację. Zastosowanie operatora referencyjnego parent:: pozwala na łatwiejsze modyfikowanie hierarchii klas. Składowe chronione Składowe chronione można stosować w PHP 5. W definicjach zmiennych i funkcji składowych może się pojawić słowo kluczowe protected, które uczyni z nich składowe chronione. Jest to rozwiązanie pośrednie między składowymi pu- blicznymi, a prywatnymi. Daje ono klasie dostęp do zmiennych i funkcji zdefiniowanych w kla- sach nadrzędnych, ale nie pozwala na odwoływanie się do nich w klasach należących do innej hierarchii klas. Oznacza to, że na przykład klasa potomna ma dostęp do chronionych funkcji klasy nadrzędnej, ale nie są one dostępne dla klas, które nie mają z nią żadnego związku, ani dla innych elementów skryptu. Na listingu 4.5 pojawiła się po raz pierwszy klasa FreightCalculator, której zadaniem jest ob- liczanie kosztów przewozu i całkowitej masy określonej liczby skrzynek. Klasa ta oblicza te war- tości korzystając z dwóch prywatnych funkcji — perCaseTotal() i perKgTotal(). Na listingu 4.9 przepisaliśmy definicję tej klasy, tym razem czyniąc te funkcje chronionymi. Pozwoli nam to wyprowadzić z klasy FreightCalculator nową klasę AirFreightCalculator (odnoszącą się do przewozów drogą lotniczą) i dokonać redefinicji funkcji, co pozwoli nam na stosowanie innych stawek za kilogram i za każdą skrzynkę. Listing 4.9. Kalkulator kosztów przewozu towarów drogą lotniczą class FreightCalculator { protected $numberOfCases; protected $totalWeight; function totalFreight() { return $this- perCaseTotal() + $this- perKgTotal(); } 138 | Rozdział 4. Wprowadzenie do programowania zorientowanego obiektowo w PHP 5 protected function perCaseTotal() { return $this- numberOfCases * 1.00; } protected function perKgTotal() { return $this- totalWeight * 0.10; } function __construct($numberOfCases, $totalWeight) { $this- numberOfCases = $numberOfCases; $this- totalWeight = $totalWeight; } } class AirFreightCalculator extends FreightCalculator { protected function perCaseTotal() { // 15 zł + 1 zł za każde opakowanie return 15 + $this- numberOfCases * 1.00; } protected function perKgTotal() { // 0.40 zł za kilogram return $this- totalWeight * 0.40; } } Ponieważ implementacja funkcji perCaseTotal() i perKgTotal() w klasie AirFreightCal- culator wymaga dostępu do zmiennych składowych $totalWeight i $numberOfCases klasy FreightCalculator, zostały one zadeklarowane jako chronione. Metody finalne Deklarowanie metod jako finalnych możliwe jest w PHP 5. W klasie AirFreightCalculator z listingu 4.9 nie pojawia się nowa definicja funkcji składowej totalFreight(), ponieważ nie ma takiej potrzeby. Jej wersja zdefiniowana w klasie Freight- Calculator prawidłowo oblicza opłatę. Istnieje możliwość zabezpieczenia się przed sytuacją, w której któraś z metod klasy bazowej mogłaby zostać ponownie zdefiniowana w klasie po- tomnej. Wystarczy zadeklarować taką metodę jako finalną. Umieszczenie w definicji funkcji składowej totalFreight() słowa kluczowego final zabezpiecza przed przypadkowym ponow- nym zdefiniowaniem tej funkcji: final function totalFreight() { return $this- perCaseTotal() + $this- perKgTotal(); } Dziedziczenie | 139 Zgłaszanie i obsługiwanie wyjątków W PHP 5 pojawił się model obsługi wyjątków pozwalający na opisywanie błędów za pośred- nictwem specjalnych obiektów. Mogą one pojawiać się w programie i zostać „wychwycone” przez specjalne procedury obsługi błędów. Do zgłaszania wyjątków służy wyrażenie throw, a do ich wychwytywania try...catch. Dzięki wyrażeniom try...catch w sytuacjach awaryjnych program może przeskoczyć bezpo- średnio do kodu obsługi danego błędu. Zamiast kończyć wykonywanie skryptu podaniem in- formacji o zaistnieniu błędu krytycznego, PHP zgłasza wyjątki, które mogą zostać w programie wychwycone i przetworzone. Wyrażenie throw jest zawsze stosowane w połączeniu z wyraże- niem try...catch. W najprostszym przypadku wygląda to tak, jak pokazujemy poniżej: $total = 100; $n = 5; $result; try { // Sprawdź wartość $n zanim jej użyjesz if ($n == 0) throw new Exception( Nie mogę przypisać n wartości zero! )n; // Oblicz średnią $result = $total / $n; } catch (Exception $x) { print Wystąpił błąd: {$x- getMessage()}; } Blok poleceń umieszczony w nawiasach klamrowych po słowie kluczowym try jest wykony- wany jak standardowa część programu. Nawiasy są obowiązkowe — nawet jeśli miałoby się w nich znaleźć tylko jedno polecenie. Jeżeli w bloku try wywołane zostanie wyrażenie throw, wówczas zostaną wykonane wszystkie polecenia umieszczone w nawiasach klamrowych po sło- wie kluczowym catch. Wyrażenie throw umieszcza w programie obiekt opisujący błąd, a wyra- żenie catch „wychwytuje” go i przypisuje go do podanej zmiennej. W wyrażeniu catch określa się też, jakiego rodzaju obiekty ma ono wychwytywać, umieszcza- jąc przed nazwą zmiennej nazwę ich klasy. Poniższy fragment kodu wychwytuje obiekty klasy Exception i przypisuje je do zmiennej $x: catch (Exception $x) { print Wystąpił błąd: {$x- getMessage()}; } Określanie w bloku catch rodzaju obiektu, jaki ma zostać wyłapany, jest przykładem podpo- wiedzi odnośnie rodzaju klasy. Podpowiedzi tego typu omawiamy w rozdziale 14. Klasa Exception Choć błędy można zgłaszać za pomocą dowolnych klas, w PHP 5 przewidziano predefiniowa- ną klasę Exception stworzoną specjalnie do tego celu. Jest ona tak skonstruowana, że świetnie się do tego nadaje. 140 | Rozdział 4. Wprowadzenie do programowania zorientowanego obiektowo w PHP 5 Tworząc obiekt klasy Exception musimy określić dla niego treść komunikatu o błędzie i opcjo- nalny kod błędu będący liczbą całkowitą. Informacje te będzie można później odczytać za pomocą funkcji składowych getMessage() i getCode(). W każdym obiekcie Exception zapa- miętywaną jest też nazwa skryptu i wiersz, w którym wystąpił błąd. Dostęp do tych informacji zapewniają funkcje składowe getFile() i getLine(). Wykorzystujemy je w kodzie pokazanym na listingu 4.10, w którym definiujemy funkcję formatException(), zwracającą dla podanego obiektu $e klasy Exception prosty komunikat o zaistniałym błędzie. Listing 4.10. Prosta sekwencja try-catch ?php function formatException(Exception $e) { return Błąd {$e- getCode()}: {$e- getMessage()} (linia: {$e- getline()} w pliku {$e- getfile()}) ; } function average($total, $n) { if ($n == 0) throw new Exception( Liczba sztuk = 0 , 1001); return $total / $n; } // Skrypt, w którym wykorzystuje się funkcję average() try { $a = average(100, 0); print Średnia = {$a} ; } catch (Exception $error) { print formatException($error); } ? Na listingu 4.10 pokazaliśmy jak za pomocą wyrażenia try...catch należy wychwytywać wy- jątki zgłaszane przez funkcję average(). Tworzony jest obiekt Exception z odpowiednim komu- nikatem i kodem błędu, który jest zgłaszany przez funkcję average() w sytuacji, gdy zmien- na $n ma wartość zero. Na listingu 4.10 funkcja average() wywoływana jest w bloku try. Dzięki temu, jeżeli zgłosi ona wyjątek, zostanie on wychwycony przez blok catch i zostanie wywołana funkcja formatException(). Nada ona komunikatowi przechowywanemu w obiek- cie $error klasy Exception postać nadającą się do wyświetlenia na ekranie. Po uruchomieniu kodu pokazanego na listingu 4.10 wywołanie funkcji average() powoduje zgłoszenie obiektu klasy Exception, co w rezultacie powoduje wyświetlenie następującego ko- munikatu: Błąd 1001: Liczba sztuk = 0 (linia: 13 w pliku c:htdocsookexample.4-10.php) Gdyby funkcja average() z listingu 4.10 została wywołana poza blokiem try...catch, zgło- szony wyjątek nie zostałby wychwycony i nastąpiłoby zakończenie wykonywania skryptu z wy- świetleniem komunikatu o nieobsłużonym wyjątku (ang. uncaught exception). Zgłaszanie i obsługiwanie wyjątków | 141 Wyrażenia try...catch stanowią alternatywę dla kończenia wykonywania skryptów polece- niami exit() i die(). Stosując je można tworzyć aplikacje, w których sytuacje awaryjne będą obsługiwane w przewidywalny sposób. Należy jednak pamiętać, że wyjątki dość mocno róż- nią się od ostrzeżeń i błędów generowanych przez PHP, gdy nie wszystko idzie tak jak trze- ba. Wyrażenia try...catch nie pozwalają niestety na obsługę błędów krytycznych, takich jak na przykład dzielenie przez zero (możesz jednak uniknąć wyświetlania komunikatów o tego rodzaju błędach stosując operator @, który opiszemy w rozdziale 6.). Kod pokazany na listin- gu 4.10 implementuje funkcję average() w taki sposób, że przed wykonaniem dzielenia spraw- dza ona wartość zmiennej $n. Pozwala to uniknąć wystąpienia krytycznego błędu dzielenia przez zero (ang. division by zero). Zarządzaniem błędami i ostrzeżeniami zgłaszanymi przez PHP zajmiemy się w rozdziale 12. 142 | Rozdział 4. Wprowadzenie do programowania zorientowanego obiektowo w PHP 5
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

PHP i MySQL. Aplikacje bazodanowe
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: