Jeszcze kilka lat temu programowanie zorientowane obiektowo w PHP wydawało się dość karkołomnym zagadnieniem. Upowszechnienie licznych frameworków sprawiło jednak, że coraz większa liczba programistów tworzy aplikacje WWW, pisząc kod obiektowy w PHP. Frameworki są chętnie stosowane, gdyż wydaje się, że dzięki nim nie trzeba już poświęcać czasu na rozgryzanie szczegółów działania kodu. Niestety, bardzo często okazuje się, że bez zrozumienia zasad działania frameworków i bez umiejętności oceny jakości zastosowanych w nich rozwiązań projektant nie jest w stanie napisać poprawnie funkcjonującej aplikacji.
Trzymasz w ręku książkę przeznaczoną dla programistów, którzy chcą dogłębnie zrozumieć mechanizmy programowania obiektowego w języku PHP i dzięki temu tworzyć, testować oraz publikować efektywny kod. Dużo uwagi poświęcono tu wzorcom projektowym i ich stosowaniu. Opisano zalety wzorców i przedstawiono sporo klasycznych już rozwiązań. Nie zabrakło również omówienia narzędzi oraz metod postępowania, dzięki którym doskonały kod staje się udanym projektem. To wszystko sprawia, że niniejsza książka jest nieodzownym podręcznikiem dla każdego projektanta, który chce tworzyć niezawodne, eleganckie i efektywne aplikacje.
Najważniejsze zagadnienia:
praca z obiektami: podstawy i zagadnienia zaawansowane
wzorce projektowe, w tym korporacyjne i bazodanowe
dobre i złe praktyki programistyczne
zarządzanie wersjami i publikowanie kodu
strategie testów automatycznych i ciągłej integracji
Twój klucz do sukcesu: eleganckie wzorce projektowe i najlepsze praktyki programistyczne!
Matt Zandstra — jest programistą WWW, konsultantem technicznym i autorem książek. Jakiś czas temu był starszym programistą w Yahoo!, a obecnie jest niezależnym konsultantem. Napisał kilka bardzo dobrze przyjętych książek o programowaniu w PHP. Specjalizuje się w rozwijaniu oprogramowania dla biznesu, zwłaszcza w PHP, Perlu i Javie, zarządzaniu treścią i programowaniu zorientowanym obiektowo. Chętnie udziela konsultacji dotyczących stosowania najlepszych praktyk programistycznych. Wraz z żoną Louise i dwójką dzieci mieszka w Liverpoolu.
Darmowy fragment publikacji:
Tytuł oryginału: PHP Objects, Patterns, and Practice, 5th Edition
Tłumaczenie: Piotr Cieślak
Projekt okładki: Studio Gravite / Olsztyn
Obarek, Pokoński, Pazdrijowski, Zaprucki
ISBN: 978-83-283-3553-0
Original edition copyright © 2016 by Matt Zandstra.
All rights reserved.
Polish edition copyright © 2017 by HELION SA.
All rights reserved.
All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means,
electronic or mechanical, including photocopying, recording or by any information storage retrieval system,
without permission from the Publisher.
Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej
publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną,
fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje
naruszenie praw autorskich niniejszej publikacji.
Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich
właścicieli.
Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock Images LLC.
Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były
kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane
z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie
ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji
zawartych w książce.
Wydawnictwo HELION
ul. Kościuszki 1c, 44-100 GLIWICE
tel. 32 231 22 19, 32 230 98 63
e-mail: helion@helion.pl
WWW: http://helion.pl (księgarnia internetowa, katalog książek)
Pliki z przykładami omawianymi w książce można znaleźć pod adresem:
ftp://ftp.helion.pl/przyklady/phpob5.zip
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/phpob5
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Printed in Poland.
• Kup książkę
• Poleć książkę
• Oceń książkę
• Księgarnia internetowa
• Lubię to! » Nasza społeczność
Spis treści
O autorze ...............................................................................................................15
O recenzencie technicznym ....................................................................................17
Podziękowania ......................................................................................................19
Wprowadzenie ......................................................................................................21
Rozdział 2.
Część I. Obiekty ..............................................................................23
PHP — projektowanie i zarządzanie ......................................................................25
Rozdział 1.
Problem ................................................................................................................................................. 25
PHP a inne języki programowania .................................................................................................... 26
O książce ............................................................................................................................................... 28
Obiekty ........................................................................................................................................... 28
Wzorce ............................................................................................................................................ 28
Narzędzia ....................................................................................................................................... 29
Nowości w piątym wydaniu ........................................................................................................ 30
Podsumowanie ..................................................................................................................................... 30
PHP i obiekty .........................................................................................................31
Nieoczekiwany sukces obiektów w PHP .......................................................................................... 31
PHP/FI — u zarania języka ......................................................................................................... 31
PHP3 — składniowy lukier ......................................................................................................... 31
Cicha rewolucja — PHP4 ............................................................................................................ 32
PHP5 — nieuchronne zmiany .................................................................................................... 33
PHP7 — doganianie reszty świata .............................................................................................. 34
Debata obiektowa — za czy przeciw? ............................................................................................... 34
Podsumowanie ..................................................................................................................................... 35
Rozdział 3. Obiektowy elementarz ..........................................................................................37
Klasy i obiekty ...................................................................................................................................... 37
Pierwsza klasa ................................................................................................................................ 37
Pierwszy obiekt (lub dwa) ........................................................................................................... 38
Definiowanie składowych klasy ......................................................................................................... 39
Poleć książkęKup książkęSPIS TREŚCI
Rozdział 4.
Metody .................................................................................................................................................. 41
Metoda konstrukcji obiektu ........................................................................................................ 42
Typy argumentów metod ................................................................................................................... 43
Typy elementarne ......................................................................................................................... 44
Typy obiektowe ............................................................................................................................. 47
Dziedziczenie ........................................................................................................................................ 50
Problemy związane z dziedziczeniem ........................................................................................ 51
Stosowanie dziedziczenia ............................................................................................................. 55
Zarządzanie dostępem do klasy — słowa public, private i protected ................................... 60
Podsumowanie ..................................................................................................................................... 64
Zaawansowana obsługa obiektów ........................................................................65
Metody i składowe statyczne .............................................................................................................. 65
Składowe stałe ...................................................................................................................................... 68
Klasy abstrakcyjne ............................................................................................................................... 69
Interfejsy ................................................................................................................................................ 71
Cechy typowe ....................................................................................................................................... 73
Zadanie dla cech typowych ......................................................................................................... 73
Definiowanie i stosowanie cechy typowej ................................................................................. 74
Stosowanie wielu cech typowych ................................................................................................ 75
Łączenie cech z interfejsami ........................................................................................................ 75
Unikanie kolizji nazw metod za pomocą słowa insteadof ...................................................... 76
Aliasy metod cech typowych ....................................................................................................... 77
Cechy typowe z metodami statycznymi .................................................................................... 78
Dostęp do składowych klasy włączającej ................................................................................... 79
Definiowanie metody abstrakcyjnej cechy typowej ................................................................. 79
Zmiana dostępności metod cech typowych .............................................................................. 80
Późne wiązanie statyczne: słowo static ............................................................................................. 81
Obsługa błędów .................................................................................................................................... 84
Wyjątki ........................................................................................................................................... 85
Klasy i metody finalne ......................................................................................................................... 92
Klasa do obsługi błędów wewnętrznych ........................................................................................... 93
Przechwytywanie chybionych wywołań ........................................................................................... 94
Definiowanie destruktorów ................................................................................................................ 99
Wykonywanie kopii obiektów ......................................................................................................... 100
Reprezentacja obiektu w ciągach znaków ...................................................................................... 103
Wywołania zwrotne, funkcje anonimowe i domknięcia .............................................................. 104
Klasy anonimowe ............................................................................................................................... 108
Podsumowanie ................................................................................................................................... 109
Rozdział 5. Narzędzia obiektowe ...........................................................................................111
PHP a pakiety ..................................................................................................................................... 111
Pakiety i przestrzenie nazw w PHP .......................................................................................... 111
Automatyczne wczytywanie kodu ............................................................................................ 119
Klasy i funkcje pomocnicze .............................................................................................................. 122
Szukanie klasy .............................................................................................................................. 123
Badanie obiektów i klas .............................................................................................................. 124
Pozyskiwanie ciągu pełnej nazwy klasy ................................................................................... 125
Badanie metod ............................................................................................................................. 126
6
Poleć książkęKup książkęSPIS TREŚCI
Badanie składowych ................................................................................................................... 127
Badanie relacji dziedziczenia ..................................................................................................... 127
Badanie wywołań metod ............................................................................................................ 128
Interfejs retrospekcji — Reflection API .......................................................................................... 129
Zaczynamy ................................................................................................................................... 129
Pora zakasać rękawy ................................................................................................................... 130
Badanie klasy ............................................................................................................................... 132
Badanie metod ............................................................................................................................. 133
Badanie argumentów metod ..................................................................................................... 135
Korzystanie z retrospekcji ......................................................................................................... 136
Podsumowanie ................................................................................................................................... 139
Rozdział 6. Obiekty a projektowanie obiektowe ...................................................................141
Czym jest projektowanie? ................................................................................................................. 141
Programowanie obiektowe i proceduralne .................................................................................... 142
Odpowiedzialność ...................................................................................................................... 145
Spójność ....................................................................................................................................... 146
Sprzęganie .................................................................................................................................... 146
Ortogonalność ............................................................................................................................. 146
Zasięg klas ........................................................................................................................................... 147
Polimorfizm ........................................................................................................................................ 148
Hermetyzacja ...................................................................................................................................... 149
Nieważne jak ....................................................................................................................................... 150
Cztery drogowskazy .......................................................................................................................... 151
Zwielokrotnianie kodu ............................................................................................................... 151
Przemądrzałe klasy ..................................................................................................................... 151
Złota rączka ................................................................................................................................. 151
Za dużo warunków ..................................................................................................................... 151
Język UML .......................................................................................................................................... 152
Diagramy klas .............................................................................................................................. 152
Diagramy sekwencji ................................................................................................................... 157
Podsumowanie ................................................................................................................................... 159
Część II. Wzorce .............................................................................161
Rozdział 7.
Czym są wzorce projektowe? Do czego się przydają? .........................................163
Czym są wzorce projektowe? ........................................................................................................... 163
Wzorzec projektowy .......................................................................................................................... 165
Nazwa ........................................................................................................................................... 165
Problem ........................................................................................................................................ 166
Rozwiązanie ................................................................................................................................. 166
Konsekwencje .............................................................................................................................. 166
Format wzorca według Bandy Czworga ......................................................................................... 166
Po co nam wzorce projektowe? ....................................................................................................... 167
Wzorzec projektowy definiuje problem .................................................................................. 167
Wzorzec projektowy definiuje rozwiązanie ............................................................................ 167
Wzorce projektowe są niezależne od języka programowania .............................................. 167
Wzorce definiują słownictwo .................................................................................................... 168
Wzorce są wypróbowane ........................................................................................................... 168
7
Poleć książkęKup książkęSPIS TREŚCI
Wzorce mają współpracować .................................................................................................... 169
Wzorce promują prawidła projektowe .................................................................................... 169
Wzorce są stosowane w popularnych frameworkach ........................................................... 169
Wzorce projektowe a PHP ............................................................................................................... 169
Podsumowanie ................................................................................................................................... 169
Rozdział 8. Wybrane prawidła wzorców ................................................................................171
Olśnienie wzorcami ........................................................................................................................... 171
Kompozycja i dziedziczenie ............................................................................................................. 172
Problem ........................................................................................................................................ 172
Zastosowanie kompozycji .......................................................................................................... 175
Rozprzęganie ...................................................................................................................................... 177
Problem ........................................................................................................................................ 178
Osłabianie sprzężenia ................................................................................................................. 179
Kod ma używać interfejsów, nie implementacji ............................................................................ 180
Zmienne koncepcje ........................................................................................................................... 181
Nadmiar wzorców ............................................................................................................................. 182
Wzorce ................................................................................................................................................ 182
Wzorce generowania obiektów ................................................................................................. 183
Wzorce organizacji obiektów i klas .......................................................................................... 183
Wzorce zadaniowe ...................................................................................................................... 183
Wzorce korporacyjne ................................................................................................................. 183
Wzorce baz danych ..................................................................................................................... 183
Podsumowanie ................................................................................................................................... 183
Generowanie obiektów .......................................................................................185
Generowanie obiektów — problemy i rozwiązania ...................................................................... 185
Wzorzec Singleton ............................................................................................................................. 189
Problem ........................................................................................................................................ 189
Implementacja ............................................................................................................................. 190
Konsekwencje .............................................................................................................................. 192
Wzorzec Factory Method ................................................................................................................. 192
Problem ........................................................................................................................................ 192
Implementacja ............................................................................................................................. 195
Konsekwencje .............................................................................................................................. 196
Wzorzec Abstract Factory ................................................................................................................ 197
Problem ........................................................................................................................................ 197
Implementacja ............................................................................................................................. 198
Konsekwencje .............................................................................................................................. 200
Prototyp ............................................................................................................................................... 201
Problem ........................................................................................................................................ 202
Implementacja ............................................................................................................................. 202
Naginanie rzeczywistości — wzorzec Service Locator ................................................................. 205
Doskonała izolacja — wstrzykiwanie zależności ........................................................................... 206
Problem ........................................................................................................................................ 207
Implementacja ............................................................................................................................. 207
Konsekwencje .............................................................................................................................. 210
Podsumowanie ................................................................................................................................... 210
Rozdział 9.
8
Poleć książkęKup książkęSPIS TREŚCI
Rozdział 10. Wzorce elastycznego programowania obiektowego ...........................................211
Strukturalizacja klas pod kątem elastyczności obiektów ............................................................. 211
Wzorzec Composite .......................................................................................................................... 211
Problem ........................................................................................................................................ 212
Implementacja ............................................................................................................................. 214
Konsekwencje .............................................................................................................................. 217
Composite — podsumowanie ................................................................................................... 220
Wzorzec Decorator ............................................................................................................................ 220
Problem ........................................................................................................................................ 221
Implementacja ............................................................................................................................. 223
Konsekwencje .............................................................................................................................. 226
Wzorzec Facade ................................................................................................................................. 226
Problem ........................................................................................................................................ 227
Implementacja ............................................................................................................................. 228
Konsekwencje .............................................................................................................................. 229
Podsumowanie ................................................................................................................................... 229
Rozdział 11. Reprezentacja i realizacja zadań ..........................................................................231
Wzorzec Interpreter .......................................................................................................................... 231
Problem ........................................................................................................................................ 231
Implementacja ............................................................................................................................. 232
Ciemne strony wzorca Interpreter ........................................................................................... 239
Wzorzec Strategy ............................................................................................................................... 240
Problem ........................................................................................................................................ 240
Implementacja ............................................................................................................................. 241
Wzorzec Observer ............................................................................................................................. 244
Implementacja ............................................................................................................................. 246
Wzorzec Visitor ................................................................................................................................. 252
Problem ........................................................................................................................................ 252
Implementacja ............................................................................................................................. 253
Wady wzorca Visitor .................................................................................................................. 258
Wzorzec Command ........................................................................................................................... 258
Problem ........................................................................................................................................ 258
Implementacja ............................................................................................................................. 259
Wzorzec Null Object ......................................................................................................................... 262
Problem ........................................................................................................................................ 263
Implementacja ............................................................................................................................. 265
Podsumowanie ................................................................................................................................... 266
Rozdział 12. Wzorce korporacyjne ...........................................................................................267
Przegląd architektury ........................................................................................................................ 267
Wzorce .......................................................................................................................................... 268
Aplikacje i warstwy ..................................................................................................................... 268
Małe oszustwo na samym początku ................................................................................................ 270
Wzorzec Registry ........................................................................................................................ 271
Implementacja ............................................................................................................................. 272
Warstwa prezentacji .......................................................................................................................... 275
Wzorzec Front Controller ......................................................................................................... 276
Wzorzec Application Controller .............................................................................................. 285
Zarządzanie danymi w komponentach ................................................................................... 290
Wzorzec Page Controller ........................................................................................................... 296
Wzorce Template View i View Helper .................................................................................... 300
9
Poleć książkęKup książkęSPIS TREŚCI
Warstwa logiki biznesowej ............................................................................................................... 302
Wzorzec Transaction Script ...................................................................................................... 303
Wzorzec Domain Model ............................................................................................................ 306
Podsumowanie ................................................................................................................................... 309
Rozdział 13. Wzorce bazodanowe ...........................................................................................311
Warstwa danych ................................................................................................................................. 311
Wzorzec Data Mapper ...................................................................................................................... 312
Problem ........................................................................................................................................ 312
Implementacja ............................................................................................................................. 312
Wzorzec Identity Map ...................................................................................................................... 325
Problem ........................................................................................................................................ 325
Implementacja ............................................................................................................................. 325
Konsekwencje .............................................................................................................................. 328
Wzorzec Unit of Work ...................................................................................................................... 328
Problem ........................................................................................................................................ 328
Implementacja ............................................................................................................................. 329
Konsekwencje .............................................................................................................................. 332
Wzorzec Lazy Load ............................................................................................................................ 332
Problem ........................................................................................................................................ 332
Implementacja ............................................................................................................................. 333
Konsekwencje .............................................................................................................................. 334
Wzorzec Domain Object Factory .................................................................................................... 334
Problem ........................................................................................................................................ 335
Implementacja ............................................................................................................................. 335
Konsekwencje .............................................................................................................................. 336
Wzorzec Identity Object ................................................................................................................... 337
Problem ........................................................................................................................................ 338
Implementacja ............................................................................................................................. 338
Konsekwencje .............................................................................................................................. 343
Wzorce Selection Factory i Update Factory .................................................................................. 343
Problem ........................................................................................................................................ 343
Implementacja ............................................................................................................................. 344
Konsekwencje .............................................................................................................................. 347
Co zostało z wzorca Data Mapper? ................................................................................................. 347
Podsumowanie ................................................................................................................................... 349
Część III. Narzędzia ........................................................................351
Rozdział 14. Dobre (i złe) praktyki ...........................................................................................353
Nie tylko kod ...................................................................................................................................... 353
Pukanie do otwartych drzwi ............................................................................................................ 354
Jak to zgrać? ........................................................................................................................................ 355
Uskrzydlanie kodu ............................................................................................................................. 356
Standardy ............................................................................................................................................ 357
Vagrant ................................................................................................................................................ 358
Testowanie .......................................................................................................................................... 358
Ciągła integracja ................................................................................................................................. 359
Podsumowanie ................................................................................................................................... 359
10
Poleć książkęKup książkęSPIS TREŚCI
Rozdział 15. Standardy PHP .....................................................................................................361
Po co te standardy? ............................................................................................................................ 361
Jakie są standardowe rekomendacje PHP? .................................................................................... 362
Dlaczego akurat PSR? ................................................................................................................. 362
Rekomendacje PSR — dla kogo? .............................................................................................. 363
Kodowanie z klasą ............................................................................................................................. 363
Podstawowy standard kodowania PSR-1 ................................................................................ 364
Rekomendacja stylu kodowania PSR-2 ................................................................................... 366
Sprawdzanie i poprawianie kodu ............................................................................................. 368
PSR-4 — automatyczne ładowanie ................................................................................................. 370
Zasady, które są dla nas ważne ................................................................................................. 370
Podsumowanie ................................................................................................................................... 373
Rozdział 16. Używanie i tworzenie komponentów PHP za pomocą Composera ......................375
Czym jest Composer? ........................................................................................................................ 375
Instalowanie Composera .................................................................................................................. 376
Instalowanie (zbioru) pakietów ....................................................................................................... 376
Instalowanie pakietu z poziomu wiersza poleceń .................................................................. 377
Wersje ........................................................................................................................................... 377
Element require-dev ................................................................................................................... 378
Composer i automatyczne ładowanie kodu ................................................................................... 379
Tworzenie własnego pakietu ............................................................................................................ 380
Dodawanie informacji o pakiecie ............................................................................................. 380
Pakiety systemowe ...................................................................................................................... 380
Dystrybucja za pośrednictwem repozytorium Packagist ............................................................. 381
Odrobina prywatności ...................................................................................................................... 384
Podsumowanie ................................................................................................................................... 385
Rozdział 17. Zarządzanie wersjami projektuz systemem Git ....................................................387
Po co mi kontrola wersji? ................................................................................................................. 387
Skąd wziąć klienta Git? ..................................................................................................................... 388
Obsługa repozytorium Git online ................................................................................................... 389
Konfigurowanie serwera Git ............................................................................................................ 391
Tworzenie repozytorium zdalnego .......................................................................................... 391
Rozpoczynamy projekt ..................................................................................................................... 393
Klonowanie repozytorium ......................................................................................................... 395
Wprowadzanie i zatwierdzanie zmian ............................................................................................ 396
Dodawanie i usuwanie plików i katalogów .................................................................................... 399
Dodawanie pliku ......................................................................................................................... 399
Usuwanie pliku ........................................................................................................................... 399
Dodawanie katalogu ................................................................................................................... 400
Usuwanie katalogów ................................................................................................................... 400
Etykietowanie wersji .......................................................................................................................... 400
Rozgałęzianie projektu ...................................................................................................................... 401
Podsumowanie ................................................................................................................................... 407
11
Poleć książkęKup książkęSPIS TREŚCI
Rozdział 18. Testy jednostkowe z PHPUnit ..............................................................................409
Testy funkcjonalne i testy jednostkowe .......................................................................................... 409
Testowanie ręczne ............................................................................................................................. 410
PHPUnit .............................................................................................................................................. 412
Tworzenie przypadku testowego .............................................................................................. 412
Metody asercji ............................................................................................................................. 414
Testowanie wyjątków ................................................................................................................. 415
Uruchamianie zestawów testów ............................................................................................... 416
Ograniczenia ................................................................................................................................ 417
Atrapy i imitacje .......................................................................................................................... 419
Dobry test to oblany test ............................................................................................................ 421
Testy dla aplikacji WWW ................................................................................................................. 423
Przygotowanie aplikacji WWW do testów ............................................................................. 424
Proste testy aplikacji WWW ..................................................................................................... 426
Selenium ....................................................................................................................................... 427
Słowo ostrzeżenia ............................................................................................................................... 432
Podsumowanie ................................................................................................................................... 434
Rozdział 19. Automatyzacja instalacji z Phingiem ...................................................................435
Czym jest Phing? ................................................................................................................................ 436
Pobieranie i instalacja pakietu Phing .............................................................................................. 436
Montowanie dokumentu kompilacji .............................................................................................. 437
Różnicowanie zadań kompilacji ............................................................................................... 438
Właściwości ................................................................................................................................. 440
Typy .............................................................................................................................................. 446
Operacje ....................................................................................................................................... 450
Podsumowanie ................................................................................................................................... 454
Rozdział 20. Vagrant ................................................................................................................455
Problem ............................................................................................................................................... 455
Odrobina przygotowań ..................................................................................................................... 456
Wybór i instalacja środowiska Vagrant ................................................................................... 456
Montowanie lokalnych katalogóww maszynie wirtualnej Vagranta ......................................... 458
Zaopatrywanie maszyny wirtualnej ................................................................................................ 459
Konfigurowanie serwera WWW .............................................................................................. 460
Konfigurowanie MySQL ............................................................................................................ 461
Konfigurowanie nazwy hosta .................................................................................................... 462
Kilka słów na koniec .......................................................................................................................... 463
Podsumowanie ................................................................................................................................... 464
Rozdział 21. Ciągła integracja kodu .........................................................................................465
Czym jest ciągła integracja? .............................................................................................................. 465
Przygotowanie projektu do ciągłej integracji ......................................................................... 467
Instalowanie Jenkinsa ................................................................................................................. 475
Instalowanie rozszerzeń Jenkinsa ............................................................................................. 475
Konfigurowanie klucza publicznego serwera Git .................................................................. 477
Instalowanie projektu ................................................................................................................. 478
Pierwsza kompilacja ................................................................................................................... 479
Konfigurowanie raportów ......................................................................................................... 482
Automatyzacja kompilacji ......................................................................................................... 484
Podsumowanie ................................................................................................................................... 486
12
Poleć książkęKup książkęSPIS TREŚCI
Rozdział 22. Obiekty, wzorce, narzędzia ..................................................................................487
Obiekty ................................................................................................................................................ 487
Wybór ........................................................................................................................................... 488
Hermetyzacja i delegowanie ...................................................................................................... 488
Osłabianie sprzężenia ................................................................................................................. 488
Zdatność do wielokrotnego stosowania kodu ........................................................................ 489
Estetyka ........................................................................................................................................ 489
Wzorce ................................................................................................................................................ 490
Co dają nam wzorce? .................................................................................................................. 490
Wzorce a zasady projektowe ..................................................................................................... 491
Narzędzia ............................................................................................................................................ 492
Testowanie ................................................................................................................................... 493
Standardy ..................................................................................................................................... 493
Zarządzanie wersjami ................................................................................................................. 493
Automatyczna kompilacja (instalacja) .................................................................................... 494
System integracji ciągłej ............................................................................................................. 494
Co pominęliśmy? ........................................................................................................................ 494
Podsumowanie ................................................................................................................................... 495
Dodatki ............................................................................497
Bibliografia ..........................................................................................................499
Książki ................................................................................................................................................. 499
Publikacje ............................................................................................................................................ 500
Witryny WWW ................................................................................................................................. 500
Prosty analizator leksykalny ................................................................................503
Skaner .................................................................................................................................................. 503
Analizator leksykalny ........................................................................................................................ 510
Skorowidz ............................................................................................................523
Dodatek A
Dodatek B
13
Poleć książkęKup książkęSPIS TREŚCI
14
Poleć książkęKup książkęR O Z D Z I A Ł 3
Obiektowy elementarz
Obiekty i klasy są sercem tej książki, a od momentu wprowadzenia PHP5 nieco ponad dekadę temu stanowią
również serce języka PHP. Niniejszy rozdział ma przygotować niezbędny grunt dla pogłębionego omówienia
obiektów i projektowania obiektowego w kontekście mechanizmów języka PHP. Ci, którym programowanie
obiektowe w tym języku jest całkiem obce, powinni przeczytać ten rozdział bardzo uważnie.
Omawiam w nim następujące zagadnienia:
Klasy i obiekty — deklarowanie klas i tworzenie ich egzemplarzy (obiektów).
Konstruktory — automatyzację konfiguracji obiektów.
Typy elementarne i klasy — jakie znaczenie ma typ w PHP.
Dziedziczenie — gdzie się przydaje i jak je stosować.
Widoczność — udostępnianie interfejsów klas i zabezpieczanie metod i składowych obiektów przed ingerencją.
Klasy i obiekty
Pierwszą przeszkodą na drodze do zrozumienia programowania obiektowego jest dziwaczność i niezwykłość
relacji pomiędzy klasą a jej obiektami. Dla wielu osób właśnie pojęcie tej relacji stanowi pierwsze olśnienie,
wywołuje pierwszą ekscytację programowaniem obiektowym. Nie skąpmy więc energii na poznawanie podstaw.
Pierwsza klasa
Klasy są często opisywane w odniesieniu do obiektów. To bardzo ciekawe, ponieważ obiekty są z kolei
niejednokrotnie opisywane przez pryzmat klas. Ta zależność bardzo spowalnia pierwsze postępy adeptów
programowania obiektowego. Ponieważ to klasy definiują obiekty, zaczniemy od definicji klasy.
Krótko mówiąc, klasa to swego rodzaju szablon wykorzystywany do generowania jednego lub większej liczby
obiektów. Deklaracja klasy zawiera słowo kluczowe class i dowolnie wybraną nazwę klasy. Nazwa klasy może
być dowolną kombinacją cyfr i liter, nie może się jednak od cyfry zaczynać. Kod skojarzony z klasą musi być
ograniczony nawiasami klamrowymi. Spróbujmy na podstawie tych informacji skonstruować klasę:
// listing 03.01
class ShopProduct
{
// ciało klasy
}
Poleć książkęKup książkęPHP. OBIEKTY, WZORCE, NARZĘDZIA
Zdefiniowana właśnie klasa ShopPoduct jest prawidłową klasą, choć jej przydatność jest na razie znikoma.
Mimo to osiągnęliśmy coś bardzo znaczącego, bo zdefiniowaliśmy typ. Utworzyliśmy więc kategorię danych,
którą możemy wykorzystywać w skryptach. Znaczenie tego faktu stanie się niebawem jaśniejsze.
Pierwszy obiekt (lub dwa)
Skoro klasa jest szablonem generowania obiektów, obiekt stanowią dane, które zostały zaaranżowane zgodnie
z szablonem definiowanym w klasie. Obiekt zwie się egzemplarzem klasy bądź jej konkretyzacją. Klasa definiuje
jego typ.
Wykorzystamy teraz klasę ShopProduct jako formę do generowania obiektów typu ShopProduct. Pomoże
nam w tym operator new. Operator new jest zazwyczaj stosowany w połączeniu z nazwą klasy, jak tutaj:
// listing 03.02
$product1 = new ShopProduct();
$product2 = new ShopProduct();
Operator new, jeśli zostanie wywoływany z nazwą klasy w roli swojego jedynego operandu, zwraca
egzemplarz tejże klasy. W naszym przykładzie generuje obiekt klasy ShopProduct.
Klasę ShopProduct wykorzystaliśmy do wygenerowania dwóch obiektów typu ShopProduct. Choć funkcjonalnie
$product1 i $product2 są identyczne (tzn. puste), stanowią obiekty rozłączne, a ich wspólnym mianownikiem
jest jedynie wspólna klasa, na podstawie której zostały wygenerowane.
Istnienie klas i obiektów można sprowadzić do następującej analogii: klasa to jakby maszyna tłocząca gumowe
kaczki. Obiektami zaś są owe gumowe kaczki produkowane przy użyciu maszyny. Ich „typ” jest wyznaczany
formą, w której są odciskane. Wszystkie wypluwane z maszyny kaczki wyglądają więc identycznie, ale są
niezależnymi od siebie obiektami materialnymi. Innymi słowy, są różnymi egzemplarzami pewnego przedmiotu.
Aby rozróżnić poszczególne kaczki, można by im zresztą podczas wytłaczania nadawać numery seryjne. Każdy
obiekt tworzony w języku PHP również posiada odrębną tożsamość, jednak unikatową jedynie w okresie życia
danego obiektu (PHP ponownie wykorzystuje nieużywane już identyfikatory obiektów w obrębie tego samego
procesu). Można się o tym przekonać, wydrukowując obiekty $product1 i $product2:
// listing 03.03
var_dump($product1);
var_dump($product2);
Wykonanie powyższego kodu spowoduje wypisanie na wyjściu:
object(popp\r03\zestaw01\ShopProduct)#235 (0) {
}
object(popp\r03\zestaw01\ShopProduct)#234 (0) {
}
Uwaga W bardzo starych wersjach PHP (do wersji 5.1 włącznie) można było wyświetlić zawartość obiektu wprost. Taka
operacja powoduje zrzutowanie obiektu na ciąg znaków zawierający identyfikator obiektu. Od PHP 5.2 język został
pozbawiony tej automagicznej konwersji, więc traktowanie obiektu jako ciągu znaków jest błędem, chyba że w klasie
obiektu jest zdefiniowana metoda __toString(). Metodami zajmiemy się w dalszej części tego rozdziału, a o metodzie
__toString() będzie mowa w rozdziale 4.
Przekazanie obiektu do wywołania var_dump() pozwala wypisać ciekawe dane o obiekcie, z identyfikatorem
obiektu na czele (po symbolu kratki).
Aby klasę ShopProduct uczynić ciekawszą, możemy uzupełnić ją o obsługę specjalnych pól danych, zwanych
składowymi bądź właściwościami (ang. properties).
38
Poleć książkęKup książkęROZDZIAŁ 3. OBIEKTOWY ELEMENTARZ
Definiowanie składowych klasy
Klasy mogą definiować specjalne zmienne zwane właściwościami bądź składowymi. Składowa przechowuje
dane, które różnią się pomiędzy egzemplarzami danej klasy. W przypadku obiektów klasy ShopProduct (niech
będzie to asortyment księgarski, choć ogólnie chodzi o dowolne artykuły) możemy na przykład zażyczyć sobie
obecności pól ceny (price) i tytułu (title).
Składowa klasy przypomina zwykłą zmienną, z tym że przy deklarowaniu składowej jej nazwę trzeba poprzedzić
słowem kluczowym określającym widoczność. Może być nim public, protected albo private. Wybór słowa
kluczowego widoczności określa zasięg, w którym możliwe będzie realizowanie odwołań do składowych.
Uwaga Zasięg to inaczej kontekst (klasy czy funkcji), w ramach którego zmienna posiada znaczenie (to samo dotyczy metod,
o których więcej w dalszej części rozdziału). Zmienna zdefiniowana wewnątrz funkcji istnieje jedynie lokalnie, a zmienna
definiowana poza funkcją istnieje globalnie. Należy przyjąć, że nie istnieje możliwość odwoływania się do danych definiowanych
w zasięgu, który jest bardziej lokalny niż bieżący. Po zdefiniowaniu zmiennej wewnątrz funkcji nie można się do niej później
odwołać spoza tejże funkcji. Obiekty są w tym względzie bardziej przenikalne — niektóre z ich zmiennych mogą
być niekiedy dostępne z innych kontekstów. Ową dostępność reguluje się słowami public, protected i private.
Do kwestii widoczności i regulujących ją słów kluczowych wrócimy później. Na razie spróbujemy po prostu
zadeklarować kilka składowych klasy za pomocą słowa kluczowego public:
// listing 03.04
class ShopProduct
{
public $title = bez tytułu ;
public $producerMainName = nazwisko ;
public $producerFirstName = imię ;
public $price = 0;
}
Jak widać, uzupełniliśmy klasę o cztery składowe, przypisując do każdej z nich wartość domyślną. Wszelkie
obiekty konkretyzowane na bazie takiej klasy będą teraz zawierać owe dane domyślne. Słowo kluczowe public
poprzedzające deklarację każdej składowej umożliwia odwoływanie się do niej spoza kontekstu obiektu.
Do składowych definiowanych w obrębie klasy, a konkretyzowanych w obiektach możemy się odwoływać
za pośrednictwem ciągu znaków „- ” (operatora obiektów) w połączeniu ze zmienną w postaci obiektu oraz nazwą
składowej:
// listing 03.05
$product1 = new ShopProduct();
print $product1- title;
bez tytułu
Ponieważ składowe zostały zdefiniowane jako publiczne (public), możemy odczytywać ich wartości i je do
nich przypisywać, zmieniając domyślne stany obiektów definiowane w klasie:
// listing 03.06
$product1 = new ShopProduct();
$product2 = new ShopProduct();
$product1- title = Moja Antonia ;
$product2- title = Paragraf 22 ;
Deklarując i ustawiając w klasie ShopProduct składową $title, wymuszamy podaną początkową wartość tej
składowej we wszystkich nowo tworzonych obiektach klasy. Oznacza to, że kod użytkujący klasę może bazować
na domniemaniu obecności tej składowej w każdym z obiektów klasy. Nie może już jednak domniemywać
wartości składowych, gdyż te — jak wyżej — mogą się w poszczególnych obiektach różnić między sobą.
39
Poleć książkęKup książkęPHP. OBIEKTY, WZORCE, NARZĘDZIA
Uwaga Kod wykorzystujący klasę, funkcję bądź metodę nazwiemy kodem klienckim wobec tej klasy, metody czy funkcji,
albo po prostu klientem klasy (metody, funkcji). Termin „klient” będzie się więc w tej książce pojawiał stosunkowo często.
Zresztą PHP nie zmusza nas do deklarowania wszystkich składowych w klasie. Obiekty można uzupełniać
składowymi dynamicznie, jak tutaj:
// listing 03.07
$product1- arbitraryAddition = nowość ;
Taka metoda uzupełniania obiekt
Pobierz darmowy fragment (pdf)