Myslenie obiektowe w programowaniu Wydanie III.pdf

(354 KB) Pobierz
Myślenie obiektowe w programowaniu. Wydanie III
Myœlenie obiektowe
w programowaniu.
Wydanie III
Autor: Matt Weisfed
T³umaczenie: £ukasz Piwko
ISBN: 978-83-246-2189-7
Process (3rd Edition)
Format: 170x230, stron: 328
Przestaw siê na myœlenie obiektowe
i twórz oprogramowanie wysokiej jakoœci
• Jak zaprojektowaæ mechanizm obs³ugi b³êdów w klasie?
• Jak tworzyæ obiekty, aby nadawa³y siê do kooperacji?
• Jak wykorzystywaæ dziedziczenie i kompozycjê?
Obiekty to twory ³¹cz¹ce w sobie zarówno dane (atrybuty), jak i procedury
(czyli zachowania). Dziêki projektowaniu obiektowemu mo¿esz w pe³ni wykorzystaæ
funkcjonalnoœæ wszystkich obiektów, zamiast traktowaæ dane i procedury jako odrêbne
jednostki, wymagaj¹ce osobnej implementacji. Programowanie obiektowe u³atwia zatem
wielokrotne wykorzystywanie kodu Ÿród³owego, ale zrozumienie tych technik wymaga
zmiany w sposobie myœlenia — na myœlenie w kategoriach obiektowych.
W ksi¹¿ce „ Myœlenie obiektowe w programowaniu. Wydanie III ” pokazano,
w jaki sposób mo¿na nauczyæ siê myœleæ obiektowo, aby zyskaæ wprawê w takim
programowaniu. Dziêki temu podrêcznikowi zrozumiesz, jak wykorzystywaæ
dziedziczenie i kompozycjê, agregacjê i asocjacjê. Dowiesz siê, na czym polega ró¿nica
miêdzy interfejsem a implementacj¹. W trzecim wydaniu szeroko opisano tak¿e
wspó³pracê ró¿nych technologii (mo¿liw¹ dziêki pomocy jêzyka XML)
oraz zamieszczono informacje dotycz¹ce dzia³ania obiektów biznesowych w sieciach.
Omówiono tu tak¿e architekturê klient-serwer oraz us³ugi sieciowe.
• Programowanie obiektowe a proceduralne
• Hermetyzacja i ukrywanie danych
• Implementacja
• Konstruktory i klasy
• Obs³uga b³êdów
• Wielokrotne u¿ycie kodu
• Serializacja i szeregowanie obiektów
• Projektowanie z wykorzystaniem obiektów
• Dziedziczenie i kompozycja
• Tworzenie modeli obiektów przy u¿yciu jêzyka UML
• Obiekty i dane przenoœne — XML
• Wzorce projektowe
Myœl obiektowo, programuj profesjonalnie!
319753045.001.png 319753045.002.png
Spis treści
O autorze ...........................................................................13
Wstęp ...............................................................................15
Rozdział 1 Wstęp do obiektowości ......................................................21
Programowanie obiektowe a proceduralne .......................................22
Zamiana podejścia proceduralnego na obiektowe ............................25
Programowanie proceduralne ....................................................26
Programowanie obiektowe ........................................................26
Definicja obiektu ...........................................................................26
Dane obiektu ...........................................................................27
Zachowania obiektu .................................................................27
Definicja klasy ..............................................................................31
Klasy są szablonami do tworzenia obiektów ...............................31
Atrybuty ...................................................................................33
Metody ...................................................................................33
Komunikaty .............................................................................33
Modelowanie diagramów UML klas .................................................34
Hermetyzacja i ukrywanie danych ....................................................34
Interfejsy .................................................................................35
Implementacje .........................................................................36
Realistyczna ilustracja paradygmatu interfejsu i implementacji .......36
Model paradygmatu interfejs – implementacja ............................37
Dziedziczenie ................................................................................38
Nadklasy i podklasy .................................................................39
Abstrakcja ...............................................................................39
Związek typu „jest” ..................................................................40
Polimorfizm ..................................................................................41
Kompozycja ..................................................................................44
Abstrakcja ...............................................................................44
Związek typu „ma” ...................................................................45
Podsumowanie .............................................................................45
6 Myślenie obiektowe w programowaniu
Listingi .........................................................................................45
TestPerson: C# .NET ................................................................45
TestPerson: VB .NET ................................................................46
TestShape: C# .NET .................................................................47
TestShape: VB .NET .................................................................48
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 ............................................69
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 w celu ich naprawienia ....................................75
Zgłaszanie wyjątków .................................................................76
Pojęcie zakresu .............................................................................78
Atrybuty lokalne .......................................................................78
Atrybuty obiektowe ...................................................................79
Atrybuty klasowe ......................................................................81
Przeciążanie operatorów ................................................................82
Wielokrotne dziedziczenie ..............................................................83
Operacje obiektów .........................................................................84
Podsumowanie .............................................................................85
Źródła ..........................................................................................85
Spis treści 7
Listingi .........................................................................................86
TestNumber: C# .NET ...............................................................86
TestNumber: VB .NET ...............................................................86
Rozdział 4 Anatomia klasy ..................................................................89
Nazwa klasy .................................................................................89
Komentarze ..................................................................................91
Atrybuty ........................................................................................91
Konstruktory .................................................................................93
Metody dostępowe ........................................................................94
Metody interfejsu publicznego ........................................................97
Prywatne metody implementacyjne .................................................97
Podsumowanie .............................................................................98
Źródła ..........................................................................................98
Listingi .........................................................................................98
TestCabbie: C# .NET ................................................................98
TestCabbie: VB .NET ................................................................99
Rozdział 5 Wytyczne dotyczące tworzenia klas ..................................101
Modelowanie systemów świata rzeczywistego ................................101
Identyfikowanie interfejsów publicznych ........................................102
Minimalizacja interfejsu publicznego ........................................102
Ukrywanie implementacji ........................................................103
Projektowanie niezawodnych konstruktorów i destruktorów .............104
Projektowanie mechanizmu obsługi błędów w klasie ......................105
Pisanie dokumentacji i stosowanie komentarzy ........................105
Tworzenie obiektów nadających się do kooperacji .....................105
Wielokrotne użycie kodu ..............................................................106
Rozszerzalność ...........................................................................106
Tworzenie opisowych nazw ......................................................107
Wyodrębnianie nieprzenośnego kodu .......................................107
Umożliwianie kopiowania i porównywania obiektów ...................108
Ograniczanie zakresu .............................................................108
Klasa powinna odpowiadać sama za siebie ..............................109
Konserwacja kodu .......................................................................111
Iteracja .................................................................................111
Testowanie interfejsu .............................................................112
Wykorzystanie trwałości obiektów .................................................113
Serializacja i szeregowanie obiektów .......................................114
Podsumowanie ...........................................................................115
Źródła ........................................................................................115
Listingi .......................................................................................115
TestMath: C# .NET .................................................................116
TestMath: VB. NET .................................................................116
8 Myślenie obiektowe w programowaniu
Rozdział 6 Projektowanie z wykorzystaniem obiektów ........................119
Wytyczne dotyczące projektowania ................................................119
Wykonanie odpowiedniej analizy ..............................................123
Określanie zakresu planowanych prac .....................................123
Gromadzenie wymagań ...........................................................124
Opracowywanie prototypu interfejsu użytkownika ......................124
Identyfikowanie klas ...............................................................124
Definiowanie wymagań wobec każdej z klas .............................125
Określenie warunków współpracy między klasami .....................125
Tworzenie modelu klas opisującego system .............................125
Studium przypadku — gra w blackjacka ........................................125
Metoda z użyciem kart CRC ....................................................127
Identyfikacja klas gry w blackjacka ..........................................128
Identyfikowanie zadań klasy ....................................................131
Przypadki użycia UML — identyfikowanie kolaboracji .................136
Pierwsza analiza kart CRC ......................................................139
Diagramy klas UML — model obiektowy ..................................139
Tworzenie prototypu interfejsu użytkownika ..............................142
Podsumowanie ...........................................................................142
Źródła ........................................................................................143
Rozdział 7 Dziedziczenie i kompozycja ...............................................145
Wielokrotne wykorzystywanie obiektów ..........................................145
Dziedziczenie ..............................................................................146
Generalizacja i specjalizacja ...................................................149
Decyzje projektowe ................................................................150
Kompozycja ................................................................................152
Reprezentowanie kompozycji na diagramach UML ....................152
Czemu hermetyzacja jest podstawą technologii obiektowej .............154
Jak dziedziczenie osłabia hermetyzację ....................................155
Szczegółowy przykład wykorzystania polimorfizmu .....................157
Odpowiedzialność obiektów ....................................................158
Podsumowanie ...........................................................................161
Źródła ........................................................................................161
Listingi .......................................................................................162
TestShape: C# .NET ...............................................................162
TestShape: VB .NET ...............................................................163
Rozdział 8 Wielokrotne wykorzystanie kodu
— interfejsy i klasy abstrakcyjne ......................................165
Wielokrotne wykorzystanie kodu ...................................................165
Infrastruktura programistyczna .....................................................166
Co to jest kontrakt ......................................................................168
Klasy abstrakcyjne .................................................................169
Interfejsy ...............................................................................172

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin