Myślenie obiektowe w programowaniu [4 ed.]

Table of contents :
Spis treści
O autorze
Wstęp
Tematyka książki
Nowości w czwartym wydaniu
Adresaci książki
Metodyka
Konwencje
Kod źródłowy
Rozdział 1. Podstawowe pojęcia obiektowości
Podstawowe pojęcia
Obiekty a stare systemy
Programowanie obiektowe a proceduralne
Zamiana podejścia proceduralnego na obiektowe
Programowanie proceduralne
Programowanie obiektowe
Definicja obiektu
Dane obiektu
Zachowania obiektu
Definicja klasy
Tworzenie obiektów
Atrybuty
Metody
Komunikaty
Modelowanie klas przy użyciu diagramów UML
Hermetyzacja i ukrywanie danych
Interfejsy
Implementacje
Realistyczna ilustracja paradygmatu interfejsu i implementacji
Model paradygmatu interfejs – implementacja
Dziedziczenie
Nadklasy i podklasy
Abstrakcja
Związek typu „jest”
Polimorfizm
Kompozycja
Abstrakcja
Związek typu „ma”
Podsumowanie
Listingi
TestPerson
TestShape
Rozdział 2. Myślenie w kategoriach obiektowych
Różnica między interfejsem a implementacją
Interfejs
Implementacja
Przykład implementacji i interfejsu
Zastosowanie myślenia abstrakcyjnego w projektowaniu interfejsów
Minimalizowanie interfejsu
Określanie grupy docelowej
Zachowania obiektu
Ograniczenia środowiska
Identyfikowanie publicznych interfejsów
Identyfikowanie implementacji
Podsumowanie
Źródła
Rozdział 3. Zaawansowane pojęcia z zakresu obiektowości
Konstruktory
Kiedy wywoływany jest konstruktor
Zawartość konstruktora
Konstruktor domyślny
Zastosowanie wielu konstruktorów
Projektowanie konstruktorów
Obsługa błędów
Ignorowanie problemu
Szukanie błędów i kończenie działania programu
Szukanie błędów i próba ich naprawienia
Zgłaszanie wyjątków
Pojęcie zakresu
Atrybuty lokalne
Atrybuty obiektowe
Atrybuty klasowe
Przeciążanie operatorów
Wielokrotne dziedziczenie
Operacje obiektów
Podsumowanie
Źródła
Listingi
TestNumber
Rozdział 4. Anatomia klasy
Nazwa klasy
Komentarze
Atrybuty
Konstruktory
Metody dostępowe
Metody interfejsu publicznego
Prywatne metody implementacyjne
Podsumowanie
Źródła
Listingi
TestCab
Rozdział 5. Wytyczne dotyczące projektowania klas
Modelowanie systemów świata rzeczywistego
Identyfikowanie interfejsów publicznych
Minimalizacja interfejsu publicznego
Ukrywanie implementacji
Projektowanie niezawodnych konstruktorów i destruktorów
Projektowanie mechanizmu obsługi błędów w klasie
Pisanie dokumentacji i stosowanie komentarzy
Tworzenie obiektów nadających się do kooperacji
Wielokrotne użycie kodu
Rozszerzalność
Tworzenie opisowych nazw
Wyodrębnianie nieprzenośnego kodu
Umożliwianie kopiowania i porównywania obiektów
Ograniczanie zakresu
Klasa powinna odpowiadać sama za siebie
Konserwacja kodu
Iteracja
Testowanie interfejsu
Wykorzystanie trwałości obiektów
Serializacja i szeregowanie obiektów
Podsumowanie
Źródła
Listingi
TestMath
Rozdział 6. Projektowanie z wykorzystaniem obiektów
Wytyczne dotyczące projektowania
Wykonanie odpowiedniej analizy
Określanie zakresu planowanych prac
Gromadzenie wymagań
Opracowywanie prototypu interfejsu użytkownika
Identyfikowanie klas
Definiowanie wymagań wobec każdej z klas
Określenie warunków współpracy między klasami
Tworzenie modelu klas opisującego system
Tworzenie prototypu interfejsu użytkownika
Obiekty opakowujące
Kod strukturalny
Opakowywanie kodu strukturalnego
Opakowywanie nieprzenośnego kodu
Opakowywanie istniejących klas
Podsumowanie
Źródła
Rozdział 7. Dziedziczenie i kompozycja
Wielokrotne wykorzystywanie obiektów
Dziedziczenie
Generalizacja i specjalizacja
Decyzje projektowe
Kompozycja
Reprezentowanie kompozycji na diagramach UML
Czemu hermetyzacja jest podstawą technologii obiektowej
Jak dziedziczenie osłabia hermetyzację
Szczegółowy przykład wykorzystania polimorfizmu
Odpowiedzialność obiektów
Klasy abstrakcyjne, metody wirtualne i protokoły
Podsumowanie
Źródła
Listingi
TestShape
Rozdział 8. Wielokrotne wykorzystanie kodu — interfejsy i klasy abstrakcyjne
Wielokrotne wykorzystanie kodu
Infrastruktura programistyczna
Co to jest kontrakt
Klasy abstrakcyjne
Interfejsy
Wnioski
Dowód kompilatora
Zawieranie kontraktu
Punkty dostępowe do systemu
Przykład biznesu elektronicznego
Biznes elektroniczny
Podejście niezakładające wielokrotnego wykorzystania kodu
Rozwiązanie dla aplikacji biznesu elektronicznego
Model obiektowy UML
Podsumowanie
Źródła
Listingi
TestShop
Rozdział 9. Tworzenie obiektów
Relacje kompozycji
Podział procesu budowy na etapy
Rodzaje kompozycji
Agregacja
Asocjacja
Łączne wykorzystanie asocjacji i agregacji
Unikanie zależności
Liczność
Kilka asocjacji
Asocjacje opcjonalne
Praktyczny przykład
Podsumowanie
Źródła
Rozdział 10. Tworzenie modeli obiektowych
Co to jest UML
Struktura diagramu klasy
Atrybuty i metody
Atrybuty
Metody
Określanie dostępności
Dziedziczenie
Interfejsy
Kompozycja
Agregacja
Asocjacja
Liczność
Podsumowanie
Źródła
Rozdział 11. Obiekty i dane przenośne — XML
Przenośność danych
Rozszerzalny język znaczników — XML
XML a HTML
XML a języki obiektowe
Wymiana danych między firmami
Sprawdzanie poprawności dokumentu względem DTD
Integrowanie DTD z dokumentem XML
Kaskadowe arkusze stylów
Notacja obiektowa języka JavaScript (JSON)
Podsumowanie
Źródła
Rozdział 12. Obiekty trwałe — serializacja i relacyjne bazy danych
Podstawy trwałości obiektów
Zapisywanie obiektu w pliku płaskim
Serializacja pliku
Jeszcze raz o implementacji i interfejsach
Serializacja metod
Serializacja przy użyciu języka XML
Zapisywanie danych w relacyjnej bazie danych
Dostęp do relacyjnej bazy danych
Podsumowanie
Źródła
Listingi
Klasa Person
Rozdział 13. Obiekty w usługach sieciowych, aplikacjach mobilnych i aplikacjach hybrydowych
Ewolucja technik przetwarzania rozproszonego
Obiektowe skryptowe języki programowania
Weryfikacja danych za pomocą języka JavaScript
Obiekty na stronach internetowych
Obiekty JavaScript
Kontrolki na stronach internetowych
Odtwarzacze dźwięku
Odtwarzacze filmów
Animacje Flash
Obiekty rozproszone i systemy przedsiębiorstw
CORBA
Definicja usługi sieciowej
Kod usług sieciowych
Representational State Transfer (ReST)
Podsumowanie
Źródła
Rozdział 14. Obiekty w aplikacjach typu klient-serwer
Model klient-serwer
Rozwiązanie własnościowe
Kod obiektu do serializacji
Kod klienta
Kod serwera
Uruchamianie aplikacji
Technika z wykorzystaniem XML
Definicja obiektu
Kod klienta
Kod serwera
Uruchamianie programu
Podsumowanie
Źródła
Listingi
Rozdział 15. Wzorce projektowe
Historia wzorców projektowych
Wzorzec MVC języka Smalltalk
Rodzaje wzorców projektowych
Wzorce konstrukcyjne
Wzorce strukturalne
Wzorce czynnościowe
Antywzorce
Podsumowanie
Źródła
Listingi
Counter.cs
Singleton.cs
MailTool.cs
MailInterface.cs
MyMailTool.cs
Adapter.cs
Iterator.cs
Skorowidz

Citation preview

Spis treści

O autorze . .........................................................................13 Wstęp . .............................................................................15 Tematyka książki ..........................................................................15 Nowości w czwartym wydaniu .........................................................17 Adresaci książki ............................................................................17 Metodyka .....................................................................................18 Konwencje ....................................................................................19 Kod źródłowy ................................................................................19

Rozdział 1

Podstawowe pojęcia obiektowości . ...................................21 Podstawowe pojęcia ......................................................................22 Obiekty a stare systemy ................................................................22 Programowanie obiektowe a proceduralne .......................................24 Zamiana podejścia proceduralnego na obiektowe ............................27 Programowanie proceduralne ....................................................27 Programowanie obiektowe ........................................................28 Definicja obiektu ...........................................................................28 Dane obiektu ...........................................................................29 Zachowania obiektu .................................................................29 Definicja klasy ..............................................................................33 Tworzenie obiektów ..................................................................34 Atrybuty ...................................................................................35 Metody ...................................................................................36 Komunikaty .............................................................................36 Modelowanie klas przy użyciu diagramów UML ................................36 Hermetyzacja i ukrywanie danych ....................................................37 Interfejsy .................................................................................37 Implementacje .........................................................................38 Realistyczna ilustracja paradygmatu interfejsu i implementacji ....39 Model paradygmatu interfejs – implementacja ............................39

6

Myślenie obiektowe w programowaniu Dziedziczenie ................................................................................40 Nadklasy i podklasy .................................................................42 Abstrakcja ...............................................................................42 Związek typu „jest” ..................................................................42 Polimorfizm ..................................................................................44 Kompozycja ..................................................................................47 Abstrakcja ...............................................................................47 Związek typu „ma” ...................................................................47 Podsumowanie .............................................................................48 Listingi .........................................................................................48 TestPerson ..............................................................................48 TestShape ..............................................................................49

Rozdział 2

Myślenie w kategoriach obiektowych . ...............................51 Różnica między interfejsem a implementacją ...................................52 Interfejs ..................................................................................54 Implementacja .........................................................................54 Przykład implementacji i interfejsu ............................................55 Zastosowanie myślenia abstrakcyjnego w projektowaniu interfejsów .........................................................59 Minimalizowanie interfejsu .............................................................61 Określanie grupy docelowej ......................................................62 Zachowania obiektu .................................................................63 Ograniczenia środowiska ..........................................................63 Identyfikowanie publicznych interfejsów .....................................63 Identyfikowanie implementacji ..................................................64 Podsumowanie .............................................................................65 Źródła . ........................................................................................65

Rozdział 3

Zaawansowane pojęcia z zakresu obiektowości . ................67 Konstruktory .................................................................................67 Kiedy wywoływany jest konstruktor ............................................68 Zawartość konstruktora ............................................................68 Konstruktor domyślny ...............................................................69 Zastosowanie wielu konstruktorów ............................................70 Projektowanie konstruktorów ....................................................73 Obsługa błędów ............................................................................74 Ignorowanie problemu ..............................................................74 Szukanie błędów i kończenie działania programu ........................75 Szukanie błędów i próba ich naprawienia ...................................75 Zgłaszanie wyjątków .................................................................76 Pojęcie zakresu .............................................................................78 Atrybuty lokalne .......................................................................78 Atrybuty obiektowe ...................................................................79 Atrybuty klasowe ......................................................................81

Spis treści Przeciążanie operatorów ................................................................82 Wielokrotne dziedziczenie ..............................................................83 Operacje obiektów .........................................................................84 Podsumowanie .............................................................................85 Źródła . ........................................................................................85 Listingi .........................................................................................86 TestNumber ............................................................................86

Rozdział 4

Anatomia klasy . ................................................................87 Nazwa klasy .................................................................................87 Komentarze ..................................................................................89 Atrybuty ........................................................................................89 Konstruktory .................................................................................91 Metody dostępowe ........................................................................93 Metody interfejsu publicznego ........................................................95 Prywatne metody implementacyjne .................................................95 Podsumowanie .............................................................................96 Źródła . ........................................................................................96 Listingi .........................................................................................96 TestCab ..................................................................................96

Rozdział 5

Wytyczne dotyczące projektowania klas . ...........................99 Modelowanie systemów świata rzeczywistego ..................................99 Identyfikowanie interfejsów publicznych ........................................100 Minimalizacja interfejsu publicznego ........................................100 Ukrywanie implementacji ........................................................101 Projektowanie niezawodnych konstruktorów i destruktorów .............102 Projektowanie mechanizmu obsługi błędów w klasie ......................103 Pisanie dokumentacji i stosowanie komentarzy ........................103 Tworzenie obiektów nadających się do kooperacji .....................104 Wielokrotne użycie kodu ..............................................................104 Rozszerzalność ...........................................................................105 Tworzenie opisowych nazw ......................................................105 Wyodrębnianie nieprzenośnego kodu .......................................106 Umożliwianie kopiowania i porównywania obiektów ...................107 Ograniczanie zakresu .............................................................107 Klasa powinna odpowiadać sama za siebie ..............................108 Konserwacja kodu .......................................................................109 Iteracja .................................................................................110 Testowanie interfejsu .............................................................110 Wykorzystanie trwałości obiektów .................................................112 Serializacja i szeregowanie obiektów .......................................113 Podsumowanie ...........................................................................113 Źródła . ......................................................................................114

7

8

Myślenie obiektowe w programowaniu Listingi .......................................................................................114 TestMath ..............................................................................114

Rozdział 6

Projektowanie z wykorzystaniem obiektów . ......................115 Wytyczne dotyczące projektowania ................................................115 Wykonanie odpowiedniej analizy ..............................................119 Określanie zakresu planowanych prac .....................................119 Gromadzenie wymagań ...........................................................120 Opracowywanie prototypu interfejsu użytkownika ......................120 Identyfikowanie klas ...............................................................120 Definiowanie wymagań wobec każdej z klas .............................121 Określenie warunków współpracy między klasami .....................121 Tworzenie modelu klas opisującego system .............................121 Tworzenie prototypu interfejsu użytkownika ..............................121 Obiekty opakowujące ...................................................................122 Kod strukturalny ....................................................................122 Opakowywanie kodu strukturalnego .........................................124 Opakowywanie nieprzenośnego kodu .......................................125 Opakowywanie istniejących klas ..............................................126 Podsumowanie ...........................................................................127 Źródła . ......................................................................................128

Rozdział 7

Dziedziczenie i kompozycja . .............................................129 Wielokrotne wykorzystywanie obiektów ..........................................129 Dziedziczenie ..............................................................................131 Generalizacja i specjalizacja ...................................................133 Decyzje projektowe ................................................................134 Kompozycja ................................................................................136 Reprezentowanie kompozycji na diagramach UML ....................137 Czemu hermetyzacja jest podstawą technologii obiektowej .............138 Jak dziedziczenie osłabia hermetyzację ....................................139 Szczegółowy przykład wykorzystania polimorfizmu .....................141 Odpowiedzialność obiektów ....................................................141 Klasy abstrakcyjne, metody wirtualne i protokoły ......................145 Podsumowanie ...........................................................................146 Źródła . ......................................................................................147 Listingi .......................................................................................147 TestShape ............................................................................147

Rozdział 8

Wielokrotne wykorzystanie kodu — interfejsy i klasy abstrakcyjne . ....................................149 Wielokrotne wykorzystanie kodu ...................................................149 Infrastruktura programistyczna .....................................................150 Co to jest kontrakt ......................................................................152 Klasy abstrakcyjne .................................................................153 Interfejsy ...............................................................................156

Spis treści Wnioski .................................................................................158 Dowód kompilatora ................................................................160 Zawieranie kontraktu ..............................................................161 Punkty dostępowe do systemu ................................................163 Przykład biznesu elektronicznego ..................................................163 Biznes elektroniczny ...............................................................164 Podejście niezakładające wielokrotnego wykorzystania kodu ......165 Rozwiązanie dla aplikacji biznesu elektronicznego ....................167 Model obiektowy UML ............................................................167 Podsumowanie ...........................................................................170 Źródła . ......................................................................................170 Listingi .......................................................................................170 TestShop ..............................................................................171

Rozdział 9

Tworzenie obiektów . .......................................................175 Relacje kompozycji ......................................................................175 Podział procesu budowy na etapy .................................................177 Rodzaje kompozycji .....................................................................179 Agregacja ..............................................................................179 Asocjacja ..............................................................................180 Łączne wykorzystanie asocjacji i agregacji ................................181 Unikanie zależności .....................................................................182 Liczność . ...................................................................................183 Kilka asocjacji .......................................................................184 Asocjacje opcjonalne ..............................................................186 Praktyczny przykład .....................................................................186 Podsumowanie ...........................................................................187 Źródła . ......................................................................................188

Rozdział 10 Tworzenie modeli obiektowych . .......................................189 Co to jest UML ............................................................................189 Struktura diagramu klasy .............................................................190 Atrybuty i metody ........................................................................192 Atrybuty .................................................................................192 Metody .................................................................................192 Określanie dostępności ...............................................................193 Dziedziczenie ..............................................................................194 Interfejsy ....................................................................................195 Kompozycja ................................................................................196 Agregacja ..............................................................................196 Asocjacja ..............................................................................197 Liczność . ...................................................................................199 Podsumowanie ...........................................................................200 Źródła . ......................................................................................201

9

10

Myślenie obiektowe w programowaniu

Rozdział 11 Obiekty i dane przenośne — XML . ...................................203 Przenośność danych ....................................................................204 Rozszerzalny język znaczników — XML ..........................................205 XML a HTML ...............................................................................206 XML a języki obiektowe ................................................................207 Wymiana danych między firmami ..................................................208 Sprawdzanie poprawności dokumentu względem DTD ....................208 Integrowanie DTD z dokumentem XML ..........................................210 Kaskadowe arkusze stylów ..........................................................216 Notacja obiektowa języka JavaScript (JSON) ..................................217 Podsumowanie ...........................................................................222 Źródła . ......................................................................................223

Rozdział 12 Obiekty trwałe — serializacja i relacyjne bazy danych .......225 Podstawy trwałości obiektów ........................................................225 Zapisywanie obiektu w pliku płaskim ............................................226 Serializacja pliku ....................................................................227 Jeszcze raz o implementacji i interfejsach ................................229 Serializacja metod .................................................................231 Serializacja przy użyciu języka XML ...............................................231 Zapisywanie danych w relacyjnej bazie danych ...............................233 Dostęp do relacyjnej bazy danych ............................................235 Podsumowanie ...........................................................................237 Źródła . ......................................................................................237 Listingi . .....................................................................................238 Klasa Person .........................................................................238

Rozdział 13 Obiekty w usługach sieciowych, aplikacjach mobilnych i aplikacjach hybrydowych . ..............................................241 Ewolucja technik przetwarzania rozproszonego ..............................241 Obiektowe skryptowe języki programowania ...................................242 Weryfikacja danych za pomocą języka JavaScript ...........................245 Obiekty na stronach internetowych ...............................................248 Obiekty JavaScript .................................................................248 Kontrolki na stronach internetowych ........................................250 Odtwarzacze dźwięku .............................................................250 Odtwarzacze filmów ................................................................251 Animacje Flash ......................................................................252 Obiekty rozproszone i systemy przedsiębiorstw ..............................252 CORBA ..................................................................................254 Definicja usługi sieciowej ........................................................257 Kod usług sieciowych .............................................................261 Representational State Transfer (ReST) ...................................263 Podsumowanie ...........................................................................264 Źródła . ......................................................................................264

Spis treści

Rozdział 14 Obiekty w aplikacjach typu klient-serwer . ........................265 Model klient-serwer .....................................................................265 Rozwiązanie własnościowe ..........................................................266 Kod obiektu do serializacji ......................................................266 Kod klienta ............................................................................267 Kod serwera ..........................................................................269 Uruchamianie aplikacji ...........................................................270 Technika z wykorzystaniem XML ...................................................271 Definicja obiektu ....................................................................272 Kod klienta ............................................................................273 Kod serwera ..........................................................................274 Uruchamianie programu .........................................................276 Podsumowanie ...........................................................................276 Źródła . ......................................................................................276 Listingi .......................................................................................277

Rozdział 15 Wzorce projektowe . ........................................................279 Historia wzorców projektowych .....................................................280 Wzorzec MVC języka Smalltalk .....................................................280 Rodzaje wzorców projektowych .....................................................283 Wzorce konstrukcyjne .............................................................283 Wzorce strukturalne ...............................................................288 Wzorce czynnościowe .............................................................290 Antywzorce .................................................................................291 Podsumowanie ...........................................................................292 Źródła ........................................................................................292 Listingi .......................................................................................293 Counter.cs ............................................................................293 Singleton.cs ..........................................................................293 MailTool.cs ...........................................................................294 MailInterface.cs .....................................................................294 MyMailTool.cs .......................................................................295 Adapter.cs ............................................................................295 Iterator.cs .............................................................................296

Skorowidz . .......................................................................297

11

12

Myślenie obiektowe w programowaniu

O autorze Matt Weisfeld jest profesorem, programistą i pisarzem. Mieszka w Cleveland w Ohio. Zanim rozpoczął pracę na pełny etat jako wykładowca, przez 20 lat działał w branży informatycznej jako programista, przedsiębiorca i pracował jako profesor. Weisfeld jest magistrem informatyki, ukończył także magisterskie studia menedżerskie. Oprócz trzech poprzednich wydań tej książki, napisał jeszcze dwie inne publikacje na temat programowania oraz opublikował wiele artykułów w magazynach i czasopismach, takich jak developer.com, „Dr. Dobb’s Journal”, „The C/C++ Users Journal”, „Software Development Magazine”, „Java Report” oraz w wydawanym w wielu krajach periodyku „Project Management”.

14

Myślenie obiektowe w programowaniu

Wstęp Tematyka książki Jak sugeruje tytuł, tematyką książki jest obiektowy paradygmat myślenia. Oczywiście wybór tematu i tytułu książki to bardzo ważne, ale też bardzo trudne decyzje, zwłaszcza jeśli pisze się na bardzo abstrakcyjny temat. Istnieje wiele książek na różnym poziomie zaawansowania, które traktują o programowaniu obiektowym. Na półkach sklepowych można znaleźć pozycje opisujące analizę obiektową, projektowanie obiektowe, programowanie obiektowe, wzorce projektowe, dane obiektowe (XML), język UML, obiektowe programowanie dla internetu, programowanie obiektowe dla urządzeń przenośnych, różne obiektowe języki programowania oraz wiele innych zagadnień związanych z obiektowością. W tym zalewie tekstów wiele osób zapomina, że wszystkie one opierają się na jednej koncepcji — myśleniu w kategoriach obiektów. Niestety spore grono osób — w tym zarówno profesjonalni programiści, jak i rozpoczynający swoją przygodę z programowaniem studenci — zgłębia wiedzę prezentowaną w tych książkach, nie podejmując żadnego wysiłku, aby dogłębnie zrozumieć koncepcje, na których się one opierają. Twierdzę, że nauka pojęć z dziedziny obiektowości nie polega na zapoznawaniu się z konkretnymi technologiami lub narzędziami. Obiektowość, mówiąc najprościej, to specyficzny sposób myślenia. Ta książka została w całości poświęcona nauce tego rodzaju myślenia. Oddzielenie metod i narzędzi od myślenia obiektowego nie jest łatwe. Wiele osób uczy się tego sposobu myślenia właśnie na podstawie używania tych narzędzi. Kiedyś na przykład programiści języka C zapoznawali się z obiektowością poprzez migrację do języka C++. Nikt wcześniej nie uczył ich, na czym w ogóle polega sama obiektowość. Wielu programistów pierwszą styczność z obiektami miało podczas oglądania prezentacji zawierających modele obiektowe w języku UML. Ci również wcześniej nie mieli żadnego doświadczenia z obiektami. Nawet dziś, gdy internet już od wielu lat jest platformą biznesową, w wielu podręcznikach i kursach dla programistów pojęcia związane z obiektowością są objaśniane dopiero w środku zamiast na początku.

16

Myślenie obiektowe w programowaniu

Bardzo ważne jest, aby zrozumieć różnicę między nauką myślenia w kategoriach obiektowych a programowaniem w języku obiektowym. Przyszło mi to do głowy w trakcie lektury takich artykułów, jak What the UML Is — and Isn’t (Czym jest, a czym nie jest UML) Craiga Larmana — było to jeszcze przed ukazaniem się pierwszego wydania niniejszej książki. W artykule tym Larman pisze: Niestety w kontekście inżynierii oprogramowania i języka UML nabywanie umiejętności odczytywania i pisania w notacji UML wydaje się czasami być stawiane na równi z umiejętnością robienia analizy obiektowej i projektowania obiektowego. Oczywiście to nieprawda. Ta druga umiejętność jest znacznie ważniejsza od pierwszej. Dlatego też zalecam szukać takich materiałów edukacyjnych, w których umiejętności związane z analizą i projektowaniem obiektowym są stawiane wyżej niż notacja UML lub umiejętność posługiwania się narzędziami CASE.

Oczywiście znajomość języka modelowania jest ważnym etapem w rozwoju programisty, ale nie należy zapominać, że najpierw trzeba nauczyć się myślenia obiektowego. Uczenie się UML-a przed opanowaniem koncepcji obiektowości przypomina naukę odczytywania schematów układów scalonych przy braku wiedzy o elektryczności. Ten sam problem dotyczy języków programowania. Jak napisałem wcześniej, wielu programistów języka C przeszło na C++, nie zapoznając się uprzednio z obiektowością. To zawsze wychodzi podczas rozmów o pracę. Wielu programistów, którzy twierdzą, że używają języka C++, w rzeczywistości pisze programy w C przy użyciu kompilatorów C++. Nawet teraz, w dobie takich języków jak C# .NET, VB .NET, Objective-C czy Java, wystarczy w rozmowie z kandydatem do pracy zadać tylko kilka dobrze dobranych pytań, aby zorientować się, że ma problemy z podstawowymi pojęciami z zakresu obiektowości. Wczesne wersje języka Visual Basic nie są obiektowe, tak samo język C, a C++ został tak zaprojektowany, aby był z nim zgodny. Dlatego możliwe jest napisanie programu przy użyciu składni języka C, ale bez zastosowania żadnych cech charakterystycznych dla C++, i skompilowanie go przy użyciu kompilatora C++. Co gorsza, możliwe nawet jest napisanie programu z użyciem tylko obiektowych właściwości, które spowodują, że kod będzie niezrozumiały zarówno dla tych, którzy programują obiektowo, jak i dla programujących bez obiektów. Jeśli więc masz zamiar zacząć programować z zastosowaniem obiektowości, koniecznie najpierw naucz się podstaw tego paradygmatu myślenia. Oprzyj się pokusie, aby od razu zgłębiać tajniki któregoś z języków programowania (np. Objective-C, VB .NET, C++, C# .NET czy Java) lub języka modelowania (np. UML) i poświęć trochę czasu na naukę myślenia w kategoriach obiektów. Po wielu latach używania języka C pod koniec lat 80. ubiegłego stulecia po raz pierwszy zetknąłem się z językiem Smalltalk. Firma, w której wówczas pracowałem, uznała, że jej programiści powinni nauczyć się nowoczesnej technologii, która zaczynała zyskiwać popularność. Na początku zajęć wykładowca powiedział nam, że paradygmat obiektowy wymaga całkowitej zmiany sposobu myślenia (chociaż metodologia ta znana jest od mniej więcej lat 60.). Następnie stwierdził, że mimo iż wszyscy z pewnością

Nowości w czwartym wydaniu

jesteśmy dobrymi programistami, to około 10 – 20% z nas nigdy nie opanuje tego nowego sposobu myślenia. Jeśli twierdzenie to ma być prawdziwe, to może głównie dlatego, że wiele osób nigdy nie zadało sobie nawet trudu, aby zmienić swój sposób myślenia na obiektowy.

Nowości w czwartym wydaniu Jak zawsze we wstępie zaznaczam, że pisząc pierwszą wersję tej książki, miałem na myśli dzieło teoretyczne. Mimo że w drugim, trzecim i czwartym wydaniu wciąż trzymam się tego założenia, dodałem kilka praktycznych zagadnień, które dobrze pasują do koncepcji obiektowości. W rozdziałach 1. – 10. opisane są podstawowe pojęcia programowania obiektowego, natomiast w rozdziałach 11. – 15. znajdują się rozważania na temat zastosowań tych pojęć do pewnych ogólnych technologii obiektowych. Innymi słowy — w rozdziałach 1. – 10. Czytelnik znajdzie opis takich fundamentalnych dla obiektowości zagadnień jak hermetyzacja, polimorfizm, dziedziczenie itd., natomiast w rozdziałach 11. – 15. pozna ich praktyczne zastosowania. W porównaniu z poprzednimi wydaniami, wiele zagadnień zostało rozszerzonych. Oto ich lista:  Programowanie urządzeń przenośnych, czyli pisanie aplikacji dla telefonów,

aplikacji mobilnych oraz hybryd mobilno-sieciowych.  Przykłady kodu w języku Objective-C dla użytkowników środowiska iOS.  Formaty XML i JSON do wymiany danych w postaci czytelnej dla człowieka.  Renderowanie i przekształcanie danych przy użyciu technologii CSS, XSLT itd.  Usługi sieciowe, w tym SOAP (ang. Simple Object Access Protocol), RESTful itp.  Technologie klient-serwer i szeregowanie obiektów.  Trwałość danych i serializacja obiektów.  Rozszerzone przykłady kodu źródłowego w językach Java, C# .NET, VB .NET

oraz Objective-C dostępne do pobrania na serwerze FTP wydawnictwa.

Adresaci książki Książka ta ma na celu ogólnie wprowadzić Czytelnika w obiektowość, a zadaniem przykładów kodu jest wzbogacenie procesu nauki. Jedną z najtrudniejszych rzeczy podczas jej pisania było zachowanie teoretycznego charakteru przy jednoczesnym dostarczeniu solidnej bazy przykładowego kodu. Celem niniejszej książki jest pomóc Czytelnikowi zrozumieć obiektowość bez używania kompilatora. Jeśli jednak jest jakiś pod ręką, można go wykorzystać, aby lepiej zbadać kod.

17

18

Myślenie obiektowe w programowaniu

Książka jest przeznaczona dla menedżerów biznesowych, projektantów, deweloperów, programistów, kierowników projektów oraz wszystkich tych, którzy chcą ogólnie zrozumieć, o co chodzi w technice obiektowej. Lektura tej książki stanowi solidny punkt wyjścia do przeczytania innych, bardziej zaawansowanych pozycji związanych z obiektowością. Do moich ulubionych zaawansowanych pozycji na ten temat należy Object-Oriented Design In Java Stephena Gilberta i Billa McCarty’ego. Bardzo podoba mi się metodyka tej książki. Używam jej jako podręcznika na swoich zajęciach z obiektowości. Często cytuję jej fragmenty w swojej książce i zdecydowanie polecam ją do przeczytania po mojej. Inne książki, które mogę polecić, to Effective C++ Scotta Meyersa, Classical and Object-Oriented Software Engineering Stephena R. Schacha, Thinking in C++ Bruce’a Eckela, UML Distilled Martina Flowera oraz Java Design Petera Coada i Marka Mayfielda. Prowadząc zajęcia z programowania i programowania sieciowego na podstawowym poziomie w firmach i na uniwersytetach, szybko zdałem sobie sprawę, że większość osób bez trudu uczy się składni języka. Więcej trudności sprawia im zrozumienie obiektowej natury języków.

Metodyka W tym momencie powinno być oczywiste, że jestem żarliwym zwolennikiem dogłębnego zapoznania się z obiektowym paradygmatem myślenia przed rozpoczęciem nauki obiektowego języka programowania lub języka modelowania. W książce tej znajduje się mnóstwo przykładów kodu i diagramów UML, ale nie trzeba znać żadnego konkretnego języka programowania, aby je zrozumieć. Skoro więc stwierdziłem, że najpierw trzeba nauczyć się odpowiedniego sposobu myślenia, dlaczego w książce jest tyle kodu Java, C# .NET, VB .NET i Objective-C oraz diagramów UML? Po pierwsze, są to doskonałe narzędzia umożliwiające ilustrowanie koncepcji obiektowych. Po drugie, wszystkie są bardzo ważne dla obiektowości i należy o nich wspomnieć już na początku. Najważniejsze jest, aby nie koncentrować się na Javie czy jakimkolwiek innym języku programowania czy modelowania, a wykorzystać je jako pomoce pozwalające zrozumieć obiektowość. Chcę podkreślić, że naprawdę bardzo lubię używać diagramów klas UML jako wizualnej pomocy w objaśnianiu klas oraz ich atrybutów i metod. W istocie jest to jedyny rodzaj diagramu UML używany w tej książce. Uważam, że diagramy te są doskonałym narzędziem do modelowania systemów obiektowych. Modeli obiektowych używam jako pomocy naukowej do ilustrowania sposobów projektowania klas i przedstawiania występujących między nimi powiązań. Za pomocą przykładów kodu źródłowego ilustruję takie pojęcia, jak pętle czy funkcje. Jednak umiejętność czytania kodu nie jest warunkiem do zrozumienia opisywanych tu pojęć. Jeśli ktoś chce bardziej szczegółowo zgłębiać przykłady, może zaopatrzyć się w jakąś książkę opisującą składnię tych języków.

Konwencje

Nie mogę z całą pewnością stwierdzić, że w książce tej nie uczę Javy, C# .NET, VB .NET, Objective-C czy UML-a. Chociaż o tych językach można napisać osobne grube tomy. Mam jednak nadzieję, że dzięki lekturze niniejszej pozycji Czytelnik poczuje chęć sięgnięcia po kolejne publikacje o podobnej tematyce, jak analiza obiektowa czy projektowanie i programowanie obiektowe.

Konwencje W książce zastosowano następujące konwencje typograficzne:  Wiersze kodu, polecenia, instrukcje i inne związane z kodem fragmenty tekstu

są wydrukowane czcionką o stałej szerokości znaków.  Symbole zastępcze, w których miejsce należy wpisać własny tekst, są pisane

pochyloną czcionką o stałej szerokości znaków. Tekst, który należy wpisać, jest dodatkowo pogrubiony.  W książce znajdują się także następujące wyróżnione fragmenty:

Uwaga W uwagach przedstawiam interesujące fakty dotyczące opisywanego tematu — dodatkowe informacje lub wzmianki o nowych technikach.

Wskazówka We wskazówkach prezentuję różne porady i pokazuję łatwiejsze sposoby na wykonanie niektórych zadań.

Ostrzeżenie W ostrzeżeniach przestrzegam przed potencjalnymi problemami oraz radzę, jak ich uniknąć.

Kod źródłowy Kompletny kod źródłowy i przykłady opisywane w tej książce można pobrać z serwera FTP wydawnictwa Helion pod adresem ftp://ftp.helion.pl/przyklady/mysob4.zip.

19

w

w

.e b

oo

k4

al

l.p

l

Myślenie obiektowe w programowaniu

w

20

1 Podstawowe pojęcia obiektowaści

� � �

�h sięgają wczesnych oczątki programowania z zastosowaniem technologii ob lat 60. ubiegłego wieku, co dla wielu osób stanowi s r zenie. Jednak obiektowaść zaczęła się burzliwie rozwijać dopiero w p vievt'90., czyli w czasie gdy obiektowe języki programowania, takie jak Smallt +, yły już powszechnie używane. Rozwój technik obiektowych zbiega się w kryciem internetu jako narzędzia � · Innymi do prowadzenia interesów i platformy rozr� słowy -obiekty bardzo � dobrze sprawdzają się w sieci. A gdy stało s ne, że przyszłość internetu jest niezagrożona, technologie obiektowe�z na tyle dobrze rozwinięte, że można je było wykorzystać w powstających właśn � logiach sieciowych. Należy podkreślić, że tyt ł t go �ziału brzmi "Podstawowe pojęcia obiektowości". Celowo użyłem słowa "pojęc· " n?e "technologie". Technologie w branży programistycznej zmi ni s ardzo szybko, natomiast pojęcia ewoluują w wolnym tempie. Określenie "e ·ą" jest bardzo trafne, ponieważ pojęcia, mimo że nie są całkiem stabilne, z� niaJ się : bardzo powoli. W tym też tkwi największa zaleta pojęciami. Mimo że w dużej mierze pozostają spójne, podlegają zajmowania się interpretacjom, dzięki czemu można prowadzić ciekawe dyskusje na ich temat. Ewolucję obiektowaści można śledzić na przestrzeni ostatnich mniej więcej dwudziestu lat, czyli od czasu powstania pierwszych technologii branżowych, takich jak prymitywne przeglądarki internetowe z połowy lat 90., do dziś, gdy dominującą pozycję mają aplikacje sieciowe i mobilne. Jak zawsze cały czas coś się dzieje i już wkrótce mogą pojawić się nowe aplikacje hybrydowe itp. Jednak na przestrzeni wszystkich tych lat pojęcia obiektowaści były cały czas aktualne. I właśnie dlatego ten rozdział jest tak bardzo ważny, bo zawiera opis pojęć, które dziś są równie istotne jak 20 lat temu.

P

��

�e R�

� i ·

1\ �

�

�

22

Rozdział 1. Podstawowe pojęcia obiektowaści

Podstawowe pojęcia Najważniejszym celem autora tej książki jest nauczenie Czytelnika łączenia opisanych pojęć z projektowaniem systemów obiektowych. Tradycyjnie obiektowe języki programowania definiują następujące trzy pojęcia: hermetyzacja, dziedziczenie oraz polimorfizm. Jeśli w języku programowania nie ma implementacji któregoś z nich, to zazwyczaj nie uważa się go za typowy język obiektowy. Ja do tych trzech cech dołączam jeszcze kompozycję, a więc moja lista właściwości języka obiektowego jest następująca: •

hermetyzacja,

•

dziedziczenie,

•

polimorfizm,

•

kompozycja.

' ��

Wszystkie te pojęcia są szczegółowo opisane w dalszej części ksi

�po�ania tych pojęć ��podlegają ciągłym

Od pierwszego wydania tej książki borykam się z problem

�

z aktualnie stosowanymi praktykami projektowania, które p zmianom. Przykładowo od zawsze toczą się dyskusje

w projektowaniu systemów obiektowych. Czy dziedzic (Tym tematem zajmuję się nieco dalej). Nawet o unikać tej techniki.

fi'N,)rsowania dziedziczenia łe�hermetyzowuje obiekty?

te:

�� i

u programistów stara się

"'-V Q ć. Na przykład decyzja o tym,

Osobiście zawsze próbuję ściśle trzymać się

�

czy zastosujesz dziedziczenie, czy nie, powi

�

yć oparta na solidnej wiedzy o tymże

�esatami tej książki są osoby chcące poznać

dziedziczeniu. We wstępie napisałem

ogólne zasady obiektowości. D�

�ż w tym rozdziale przedstawiam opis

podstawowych pojęć progra o an� iektowego, licząc że dzięki temu Czytelnik będzie w przyszłości mógł p · o�ać właściwe decyzje podczas pisania swoich

�_i�e ej części dotyczą większości, a może nawet wszystkiego, � o czym jest mowa w p�Lych, bardziej szczegółowych rozdziałach. programów. Tematy o

�

Obiekty a stare systemy Gdy obiektowaść weszła do powszechnego użytku, programiści stanęli przed problemem połączenia nowych technik obiektowych z istniejącymi systemami. W tamtych czasach wyraźnie oddzielano programowanie obiektowe od dominującego wówczas podejścia proceduralnego (strukturalnego). Zawsze mnie to dziwiło, ponieważ moim zdaniem te dwie metodologie programowania nie są dla siebie nawzajem konkurencją. Raczej się uzupełniają, bo przecież obiekty bardzo dobrze integrują się z kodem proceduralnym. Do tej pory od czasu do czasu słyszę pytania typu "Jesteś programistą obiektowym czy strukturalnym?". Bez wahania odpowiadam, że zarówno jednym, jak i drugim. Analogicznie kod obiektowy nie ma zastąpić strukturalnego. Istnieje wiele starych systemów niewykorzystujących technik obiektowych i działających bez zarzutu,

Obiekty a stare systemy

po co więc ryzykować problemy, aby je zmienić? W wielu przypadkach nie należy ich ruszać, a już na pewno nie tylko po to, aby zmienić metodę programowania. Systemy napisane przy użyciu nieobiektowych technik nie są z natury złe. Jednak przy tworzeniu nowych programów zdecydowanie zaleca się poważne rozpatrzenie możliwości wykorzystania technik obiektowych. Mimo że w ciągu ostatnich dwudziestu lat można zauważyć stały znaczny wzrost zainteresowania obiektowością, tym, co pozwoliło jej jeszcze szybciej wedrzeć się na salony technologii głównego strumienia, jest internet. Dzięki prezentowaniu w nim codziennych transakcji biznesowych pojawiły się nowe możliwości. Większość wykorzystywanego w tych celach oprogramowania jest nowa, a więc nieskażona starszymi naleciałościami. Nawet tam, gdzie coś takiego ma miejsce, istnieje tendencja do opakowywania starych systemów w specjalne obiekty oslonowe (ang. wrapper).

�

Obiekty osłonowe

��

�

Obiekt osłonowy to obiektowy kod zawierający w swoim w

iT

od. Można

na przykład opakować strukturalny moduł w obiekt osłon

,

by wyglądał jak

obiekt. W obiektach takich można także ukrywać fu �..

a przykład

� ?�ółowy opis technik z.. � � się w rozdziale 6.

zabezpieczające, nieprzenośne funkcje sprzętu it s opakowywania kodu strukturalnego w obiek z aj

�

�nia jest dzisiaj mariaż starych

1 : Jedną z najbardziej interesujących dziedzin prop-r·1� i internetowych systemów. W wielu pr

ad

Poszukiwani są zatem programiści, k órz jak i dla sieci.

� iVc

Prawdopodobnie masz do czyn

�

w handlu elektra

zasie jazdy samochodem, rozmowy przez telefon

frowej i w wielu innych sytuacjach. Elektroniczna

JJL.':' au stradę obiektów. W miarę jak biznes zatacza coraz � liża się także coraz bardziej do obiektowości, ponieważ

autostrada przeobraziła s to węższe koła wokół

tr fią programować zarówno dla serwerów,

Q