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