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)
  
• 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)
  
• 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)

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)
  • Wnioski (173)
  • Dowód kompilatora (176)
  • Zawieranie kontraktu (176)
  • Punkty dostępowe do systemu (179)
• Przykład biznesu elektronicznego (179)
  
  • Biznes elektroniczny (179)
  • Podejście niezakładające wielokrotnego wykorzystania kodu (180)
  • Rozwiązanie dla aplikacji biznesu elektronicznego (182)
  • Model obiektowy UML (182)
• Podsumowanie (186)
  
• Źródła (186)
  
• Listingi (186)
  
  • TestShop: C# .NET (187)
  • TestShop: VB .NET (189)

Rozdział 9. Tworzenie obiektów (193)

• Relacje kompozycji (193)
  
• Podział procesu budowy na etapy (195)
  
• Rodzaje kompozycji (197)
  
  • Agregacja (197)
  • Asocjacja (198)
  • Łączne wykorzystanie asocjacji i agregacji (199)
• Unikanie zależności (200)
  
• Liczność (201)
  
  • Kilka asocjacji (202)
  • Asocjacje opcjonalne (204)
• Praktyczny przykład (204)
  
• Podsumowanie (205)
  
• Źródła (206)

Rozdział 10. Tworzenie modeli obiektów przy użyciu języka UML (207)

• Co to jest UML (207)
  
• Struktura diagramu klasy (208)
  
• Atrybuty i metody (210)
  
  • Atrybuty (210)
  • Metody (210)
• Określanie dostępności (211)
  
• Dziedziczenie (212)
  
• Interfejsy (213)
  
• Kompozycja (213)
  
  • Agregacja (214)
  • Asocjacja (215)
• Liczność (216)
  
• Podsumowanie (218)
  
• Źródła (218)

Rozdział 11. Obiekty i dane przenośne - XML (219)

• Przenośność danych (219)
  
• Rozszerzalny język znaczników - XML (221)
  
• XML a HTML (221)
  
• XML a języki obiektowe (222)
  
• Wymiana danych między firmami (224)
  
• Sprawdzanie poprawności dokumentu względem DTD (224)
  
• Integrowanie DTD z dokumentem XML (226)
  
• Kaskadowe arkusze stylów (231)
  
• Podsumowanie (233)
  
• Źródła (234)

Rozdział 12. Obiekty trwałe - serializacja i relacyjne bazy danych (235)

• Podstawy trwałości obiektów (235)
  
• Zapisywanie obiektu w pliku płaskim (236)
  
  • Serializacja pliku (237)
  • Jeszcze raz o implementacji i interfejsach (239)
  • Serializacja metod (241)
• Serializacja przy użyciu języka XML (241)
  
• Zapisywanie danych w relacyjnej bazie danych (243)
  
  • Dostęp do relacyjnej bazy danych (245)
• Ładowanie sterownika (247)
  
  • Nawiązywanie połączenia (248)
  • Kwerendy SQL (248)
• Podsumowanie (251)
  
• Źródła (251)
  
• Listingi (252)
  
  • Klasa Person: C# .NET (252)
  • Klasa Person: VB .NET (254)

Rozdział 13. Obiekty a internet (257)

• Ewolucja technik przetwarzania rozproszonego (257)
  
• Obiektowe skryptowe języki programowania (258)
  
• Weryfikacja danych za pomocą języka JavaScript (260)
  
• Obiekty na stronach internetowych (263)
  
  • Obiekty JavaScript (263)
  • Kontrolki na stronach internetowych (265)
  • Odtwarzacze dźwięku (265)
  • Odtwarzacze filmów (266)
  • Animacje Flash (267)
• Obiekty rozproszone i systemy przedsiębiorstw (267)
  
  • CORBA (268)
  • Definicja usługi sieciowej (272)
  • Kod usług sieciowych (276)
  • Invoice.cs (276)
  • Invoice.vb (277)
• Podsumowanie (278)
  
• Źródła (278)

Rozdział 14. Obiekty w aplikacjach typu klient-serwer (281)

• Model klient-serwer (281)
  
• Rozwiązanie własnościowe (282)
  
  • Kod obiektu do serializacji (282)
  • Kod klienta (283)
  • Kod serwera (285)
  • Uruchamianie aplikacji (286)
• Technika z wykorzystaniem XML (286)
  
  • Definicja obiektu (287)
  • Kod klienta (288)
  • Kod serwera (290)
  • Uruchamianie programu (291)
• Podsumowanie (292)
  
• Źródła (292)
  
• Listingi (292)
  
  • Definicja obiektu w języku VB .NET (292)
  • Kod klienta w języku VB .NET (293)
  • Kod serwera w języku VB .NET (294)

Rozdział 15. Wzorce projektowe (297)

• Historia wzorców projektowych (298)
  
• Wzorzec MVC języka Smalltalk (298)
  
• Rodzaje wzorców projektowych (300)
  
  • Wzorce konstrukcyjne (301)
  • Wzorce strukturalne (305)
  • Wzorce czynnościowe (307)
• Antywzorce (309)
  
• Podsumowanie (310)
  
• Źródła (310)
  
• Listingi (310)
  
  • C# .NET (310)
  • VB .NET (314)

Skorowidz (317)