Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00474 013793 11056520 na godz. na dobę w sumie
Programowanie zorientowane obiektowo - książka
Programowanie zorientowane obiektowo - książka
Autor: Liczba stron: 1464
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-738-8 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> techniki programowania
Porównaj ceny (książka, ebook, audiobook).

Poznaj reguły projektowania i programowania obiektowego

Programowanie zorientowane obiektowo to technika, która w ciągu ostatnich lat zyskała niezwykłą popularność. Języki programowania obiektowego święcą triumfy, a metodologie projektowania oparte na analizie obiektowej stają się standardami przemysłowymi. Założenia analizy i programowania obiektowego są pozornie proste, jednakże bez ich właściwego zrozumienia nie można zaprojektować prawidłowo aplikacji implementowanej w obiektowym języku programowania. Technologia obiektowa zmieniła cały przemysł programistyczny, więc jej opanowanie jest niezbędnym elementem wiedzy każdego informatyka, który chce wykorzystywać w pracy nowoczesne metody i techniki.

Książka 'Programowanie zorientowane obiektowo' to wyczerpujące omówienie wszystkich zagadnień związanych z projektowaniem i programowaniem obiektowym. Opisuje główne elementy techniki obiektowej oraz wiele spośród ich potencjalnych zastosowań. Dzięki książce poznasz również metodykę projektowania oprogramowania, dowiesz się, czym są wzorce projektowe, i nauczysz się, w jaki sposób zaimplementować lub zasymulować techniki obiektowe w różnych językach programowania.

Wykorzystaj techniki obiektowe i popraw jakość
tworzonego przez siebie oprogramowania.

O autorze:
Bertrand Meyer -- autor bestselerów, mający na swoim koncie już dziesięć książek, publikował zarówno pozycje teoretyczne, jak i poświęcone praktycznym zastosowaniom technologii obiektowej, a nawet zarządzaniu. [więcej...\

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREŒCI SPIS TREŒCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOŒCIACH O NOWOŒCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Programowanie zorientowane obiektowo Autor: Bertrand Meyer T³umaczenie: Micha³ Dadan (wstêp, rozdz. 1–6, 9, 10, 15, dod. A, C, D), Jaros³aw Dobrzañski (rozdz. 7, 17–25), Jan Ostrowski (rozdz. 26–32), Jaromir Senczyk (rozdz. 16, 33–36, dod. B), Krzysztof Szafranek (rozdz. 8, 11–14) ISBN: 83-7361-738-8 Tytu³ orygina³u: Object-Oriented Software Construction Second Edition Format: B5, stron: 1464 Poznaj regu³y projektowania i programowania obiektowego (cid:127) Elementy techniki obiektowej (cid:129) Metodyka tworzenia oprogramowania (cid:129) Implementacja mechanizmów obiektowych Programowanie zorientowane obiektowo to technika, która w ci¹gu ostatnich lat zyska³a niezwyk³¹ popularnoœæ. Jêzyki programowania obiektowego œwiêc¹ triumfy, a metodologie projektowania oparte na analizie obiektowej staj¹ siê standardami przemys³owymi. Za³o¿enia analizy i programowania obiektowego s¹ pozornie proste, jednak¿e bez ich w³aœciwego zrozumienia nie mo¿na zaprojektowaæ prawid³owo aplikacji implementowanej w obiektowym jêzyku programowania. Technologia obiektowa zmieni³a ca³y przemys³ programistyczny, wiêc jej opanowanie jest niezbêdnym elementem wiedzy ka¿dego informatyka, który chce wykorzystywaæ w pracy nowoczesne metody i techniki. Ksi¹¿ka „Programowanie zorientowane obiektowo” to wyczerpuj¹ce omówienie wszystkich zagadnieñ zwi¹zanych z projektowaniem i programowaniem obiektowym. Opisuje g³ówne elementy techniki obiektowej oraz wiele spoœród ich potencjalnych zastosowañ. Dziêki ksi¹¿ce poznasz równie¿ metodykê projektowania oprogramowania, dowiesz siê, czym s¹ wzorce projektowe, i nauczysz siê, w jaki sposób zaimplementowaæ lub zasymulowaæ techniki obiektowe w ró¿nych jêzykach programowania. (cid:129) Podstawowe elementy projektowania obiektowego (cid:129) Wielokrotne wykorzystywanie kodu (cid:129) Analiza obiektowa (cid:129) Abstrakcyjne typy danych (cid:129) Klasy i obiekty (cid:129) Zarz¹dzanie pamiêci¹ (cid:129) Mechanizmy dziedziczenia (cid:129) Obs³uga wyj¹tków (cid:129) Metodyka projektowania obiektowego (cid:129) Programowanie wspó³bie¿ne (cid:129) Obiektowe bazy danych (cid:129) Zastosowanie technik obiektowych w ró¿nych jêzykach programowania Wykorzystaj techniki obiektowe i popraw jakoœæ tworzonego przez siebie oprogramowania SPIS TREŚCI O Autorze .............................................................................................................15 Wstęp ....................................................................................................................17 27 Część I Podstawy 1. Jakość oprogramowania .....................................................................................29 1.1. Czynniki zewnętrzne i wewnętrzne ........................................................................................................29 1.2. Przegląd czynników zewnętrznych ........................................................................................................30 1.3. Konserwacja oprogramowania ...............................................................................................................45 1.4. Kluczowe pojęcia wprowadzone w tym rozdziale .................................................................................47 1.5. Bibliografia ............................................................................................................................................48 2. Kryteria obiektowości .........................................................................................51 2.1. O kryteriach ...........................................................................................................................................52 2.2. Technika i język .....................................................................................................................................53 2.3. Implementacja i środowisko ...................................................................................................................63 2.4. Biblioteki ................................................................................................................................................65 2.5. Rzut oka na konkretny projekt ...............................................................................................................67 2.6. Bibliografia (w tym materiały na temat obiektów) .................................................................................67 Część II W stronę obiektowości 69 3. Modułowość .........................................................................................................71 3.1. Pięć kryteriów ........................................................................................................................................72 3.2. Pięć reguł ...............................................................................................................................................79 3.3. Pięć zasad ...............................................................................................................................................86 4 SPIS TREŚCI 3.4. Kluczowe pojęcia wprowadzone w tym rozdziale .................................................................................97 3.5. Bibliografia ............................................................................................................................................98 Ćwiczenia .......................................................................................................................................................99 4. Wielokrotne wykorzystywanie kodu ...............................................................101 4.1. Cele wielokrotnego wykorzystywania kodu .........................................................................................102 4.2. Jakie elementy systemów nadają się do wielokrotnego wykorzystywania? .........................................105 4.3. Powtórzenia w procesie tworzenia systemu .........................................................................................109 4.4. Problemy nietechniczne .......................................................................................................................110 4.5. Problem natury technicznej ..................................................................................................................118 4.6. Pięć wymagań dotyczących struktury modułów ..................................................................................120 4.7. Tradycyjne struktury modułowe ..........................................................................................................126 4.8. Przeciążanie i generyczność .................................................................................................................131 4.9. Kluczowe pojęcia wprowadzone w tym rozdziale ...............................................................................137 4.10. Bibliografia ..........................................................................................................................................138 5. W stronę techniki obiektowej ..........................................................................141 5.1. Składniki „obliczeń” ............................................................................................................................141 5.2. Dekompozycja funkcjonalna ................................................................................................................143 5.3. Dekompozycja obiektowa ....................................................................................................................155 5.4. Programowanie zorientowane obiektowo ............................................................................................157 5.5. Pytania .................................................................................................................................................158 5.6. Kluczowe pojęcia wprowadzone w tym rozdziale ...............................................................................160 5.7. Bibliografia ..........................................................................................................................................161 6. Abstrakcyjne typy danych ...............................................................................163 6.1. Kryteria ................................................................................................................................................164 6.2. Możliwe implementacje .......................................................................................................................164 6.3. W stronę abstrakcyjnego postrzegania obiektów .................................................................................168 6.4. Formalizacja specyfikacji .....................................................................................................................172 6.5. Od abstrakcyjnych typów danych do klas ............................................................................................186 6.6. Nie tylko oprogramowanie ...................................................................................................................191 6.7. Informacje uzupełniające .....................................................................................................................192 6.8. Kluczowe pojęcia wprowadzone w tym rozdziale ...............................................................................204 6.9. Bibliografia ..........................................................................................................................................205 Ćwiczenia .....................................................................................................................................................206 209 Część III Techniki obiektowe 7. Klasy — struktura statyczna ...........................................................................211 7.1. Obiekty nie są najważniejsze ...............................................................................................................211 7.2. Unikanie typowych nieporozumień ......................................................................................................212 SPIS TREŚCI 5 7.3. Znaczenie klas ......................................................................................................................................216 7.4. Jednolity system typów ........................................................................................................................217 7.5. Prosta klasa ..........................................................................................................................................218 7.6. Podstawowe konwencje .......................................................................................................................223 7.7. Przebieg wykonania programu obiektowego ........................................................................................227 7.8. Eksportowanie wybiórcze a ukrywanie informacji ..............................................................................238 7.9. Składanie wszystkiego w całość ...........................................................................................................241 7.10. Analiza .................................................................................................................................................250 7.11. Kluczowe pojęcia wprowadzone w tym rozdziale ...............................................................................262 7.12. Bibliografia ..........................................................................................................................................263 Ćwiczenia .....................................................................................................................................................264 8. Struktury czasu wykonywania: obiekty .........................................................265 8.1. Obiekty .................................................................................................................................................266 8.2. Obiekty jako narzędzie do modelowania ..............................................................................................277 8.3. Manipulowanie obiektami i referencjami .............................................................................................280 8.4. Procedury tworzące ..............................................................................................................................285 8.5. Więcej o referencjach ...........................................................................................................................289 8.6. Operacje na referencjach ......................................................................................................................291 8.7. Obiekty złożone i typy rozszerzone .....................................................................................................303 8.8. Wiązanie: semantyka referencji i wartości ...........................................................................................310 8.9. Korzystanie z referencji: korzyści i zagrożenia ....................................................................................315 8.10. Analiza .................................................................................................................................................320 8.11. Kluczowe pojęcia wprowadzone w tym rozdziale ...............................................................................325 8.12. Bibliografia ..........................................................................................................................................326 Ćwiczenia .....................................................................................................................................................327 9. Zarządzanie pamięcią .......................................................................................329 9.1. Co dzieje się z obiektami? ....................................................................................................................329 9.2. Podejście klasyczne ..............................................................................................................................342 9.3. Zagadnienia związane z odzyskiwaniem pamięci ................................................................................345 9.4. Dealokacja kontrolowana przez programistę ........................................................................................346 9.5. Rozwiązanie na poziomie komponentów .............................................................................................349 9.6. Automatyczne zarządzanie pamięcią ...................................................................................................354 9.7. Zliczanie referencji ...............................................................................................................................355 9.8. Oczyszczanie pamięci ..........................................................................................................................357 9.9. Mechanizm oczyszczania pamięci w praktyce .....................................................................................364 9.10. Środowisko z zaimplementowanym odzyskiwaniem pamięci .............................................................367 9.11. Kluczowe pojęcia wprowadzone w tym rozdziale ...............................................................................370 9.12. Bibliografia ..........................................................................................................................................371 Ćwiczenia .....................................................................................................................................................372 10. Generyczność .....................................................................................................373 10.1. Pozioma i pionowa generalizacja typów ............................................................................................374 10.2. Potrzeba parametryzacji typów ..........................................................................................................374 10.3. Klasy generyczne ...............................................................................................................................377 6 SPIS TREŚCI 10.4. Tablice ................................................................................................................................................382 10.5. Koszt generyczności ...........................................................................................................................386 10.6. Analiza — to jeszcze nie koniec ........................................................................................................387 10.7. Kluczowe pojęcia wprowadzone w tym rozdziale .............................................................................387 10.8. Bibliografia ........................................................................................................................................388 Ćwiczenia .....................................................................................................................................................388 11. Projektowanie kontraktowe: tworzenie niezawodnego oprogramowania ....391 11.1. Proste mechanizmy niezawodności ....................................................................................................392 11.2. O poprawności oprogramowania ........................................................................................................393 11.3. Specyfikacja .......................................................................................................................................394 11.4. Wprowadzanie asercji do kodu ..........................................................................................................397 11.5. Warunki początkowe i warunki końcowe ..........................................................................................398 11.6. Używanie kontraktów dla poprawy niezawodności ...........................................................................402 11.7. Praca z asercjami ................................................................................................................................408 11.8. Niezmienniki klas ...............................................................................................................................422 11.9. Kiedy klasa jest poprawna? ................................................................................................................428 11.10. Związek z ATD ..................................................................................................................................432 11.11. Instrukcja asercji ................................................................................................................................436 11.12. Niezmienniki i zmienne pętli .............................................................................................................439 11.13. Korzystanie z asercji ..........................................................................................................................447 11.14. Analiza ...............................................................................................................................................456 11.15. Kluczowe pojęcia wprowadzone w tym rozdziale .............................................................................465 11.16. Bibliografia ........................................................................................................................................466 Ćwiczenia .....................................................................................................................................................467 Postscriptum: katastrofa Ariane 5 .................................................................................................................469 12. Gdy kontrakt nie zostaje dotrzymany: obsługa wyjątków ...........................471 12.1. Podstawy obsługi wyjątków ...............................................................................................................471 12.2. Obsługa wyjątków ..............................................................................................................................474 12.3. Mechanizm wyjątków ........................................................................................................................479 12.4. Przykłady obsługi wyjątków ..............................................................................................................482 12.5. Zadanie klauzuli ratunkowej ..............................................................................................................488 12.6. Zaawansowana obsługa wyjątków .....................................................................................................491 12.7. Analiza ...............................................................................................................................................496 12.8. Kluczowe pojęcia wprowadzone w tym rozdziale .............................................................................498 12.9. Bibliografia ........................................................................................................................................498 Ćwiczenia .....................................................................................................................................................499 13. Mechanizmy pomocnicze ..................................................................................501 13.1. Komunikacja z oprogramowaniem nieobiektowym ...........................................................................501 13.2. Przekazywanie argumentów ...............................................................................................................507 13.3. Instrukcje ............................................................................................................................................509 13.4. Wyrażenia ..........................................................................................................................................515 SPIS TREŚCI 7 13.5. Łańcuchy znaków ...............................................................................................................................520 13.6. Wejście i wyjście ................................................................................................................................521 13.7. Konwencje leksykalne ........................................................................................................................521 13.8. Kluczowe pojęcia wprowadzone w tym rozdziale .............................................................................521 Ćwiczenia .....................................................................................................................................................522 14. Wprowadzenie do dziedziczenia ......................................................................523 14.1. Wielokąty i prostokąty .......................................................................................................................524 14.2. Polimorfizm .......................................................................................................................................531 14.3. Kontrola typów a dziedziczenie .........................................................................................................536 14.4. Dynamiczne wiązanie ........................................................................................................................545 14.5. Cechy i klasy abstrakcyjne .................................................................................................................547 14.6. Techniki ponownej deklaracji ............................................................................................................556 14.7. Znaczenie dziedziczenia .....................................................................................................................560 14.8. Rola klas abstrakcyjnych ....................................................................................................................566 14.9. Analiza ...............................................................................................................................................573 14.10. Kluczowe pojęcia wprowadzone w tym rozdziale .............................................................................583 14.11. Bibliografia ........................................................................................................................................584 Ćwiczenia .....................................................................................................................................................585 15. Dziedziczenie wielokrotne ................................................................................587 15.1. Przykłady dziedziczenia wielokrotnego .............................................................................................587 15.2. Zmiana nazw cech ..............................................................................................................................604 15.3. Spłaszczanie struktury ........................................................................................................................611 15.4. Powtórne dziedziczenie ......................................................................................................................614 15.5. Analiza ...............................................................................................................................................635 15.6. Kluczowe pojęcia wprowadzone w tym rozdziale .............................................................................638 15.7. Bibliografia ........................................................................................................................................638 Ćwiczenia .....................................................................................................................................................639 16. Techniki dziedziczenia ......................................................................................643 16.1. Dziedziczenie i asercje .......................................................................................................................644 16.2. Globalna struktura dziedziczenia .......................................................................................................656 16.3. Cechy zamrożone ...............................................................................................................................659 16.4. Generyczność ograniczona .................................................................................................................661 16.5. Próba przypisania ...............................................................................................................................667 16.6. Zgodność typów i ponowne deklaracje ..............................................................................................672 16.7. Deklaracje kotwiczone .......................................................................................................................675 16.8. Dziedziczenie i ukrywanie informacji ................................................................................................683 16.9. Kluczowe pojęcia wprowadzone w tym rozdziale .............................................................................688 16.10. Bibliografia ........................................................................................................................................689 Ćwiczenia .....................................................................................................................................................689 8 SPIS TREŚCI 17. Kontrola typów ..................................................................................................691 17.1. Problem z kontrolą typów ..................................................................................................................691 17.2. Statyczna kontrola typów — kiedy i jak? ...........................................................................................696 17.3. Kowariancja i ukrywanie u potomków ...............................................................................................703 17.4. Pierwsze podejście do kwestii poprawności systemu .........................................................................711 17.5. Bazowanie na typach zakotwiczonych ...............................................................................................713 17.6. Analiza globalna .................................................................................................................................717 17.7. Uwaga na polimorficzne wywołania ZDLT! ......................................................................................719 17.8. Ocena .................................................................................................................................................722 17.9. Idealny typ .........................................................................................................................................723 17.10. Kluczowe pojęcia wprowadzone w tym rozdziale .............................................................................725 17.11. Bibliografia ........................................................................................................................................725 18. Obiekty i stałe globalne ....................................................................................727 18.1. Stałe podstawowych typów ................................................................................................................728 18.2. Korzystanie ze stałych ........................................................................................................................729 18.3. Stałe o typach będących klasami ........................................................................................................730 18.4. Zastosowanie podprogramów jednorazowych ...................................................................................732 18.5. Stałe typu łańcuchowego ....................................................................................................................738 18.6. Wartości unikatowe ............................................................................................................................738 18.7. Analiza ...............................................................................................................................................740 18.8. Kluczowe pojęcia wprowadzone w tym rozdziale .............................................................................744 18.9. Bibliografia ........................................................................................................................................745 Ćwiczenia .....................................................................................................................................................745 Część IV Metodyka obiektowa — prawidłowe stosowanie metody 19. O metodyce ........................................................................................................749 19.1. Metodyka programowania — jak i dlaczego? ....................................................................................749 19.2. Wymyślanie dobrych reguł — porady dla radzących .........................................................................750 19.3. O użyciu metafor ................................................................................................................................758 19.4. Znaczenie pokory ...............................................................................................................................760 19.5. Bibliografia ........................................................................................................................................761 Ćwiczenia .....................................................................................................................................................761 20. Wzorzec projektowy — wielopanelowe systemy interaktywne ....................763 20.1. Systemy wielopanelowe .....................................................................................................................763 20.2. Proste rozwiązanie .............................................................................................................................765 747 SPIS TREŚCI 9 20.3. Rozwiązanie hierarchiczne z funkcjami .............................................................................................766 20.4. Krytyka rozwiązania ..........................................................................................................................770 20.5. Architektura obiektowa ......................................................................................................................772 20.6. Analiza ...............................................................................................................................................781 20.7. Bibliografia ........................................................................................................................................782 21. Dziedziczenie — studium przypadku: operacja „cofnij” w systemie interaktywnym ................................................783 21.1. Perseverare diabolicum ......................................................................................................................783 21.2. Wyszukiwanie abstrakcji ....................................................................................................................787 21.3. Wielopoziomowy mechanizm cofnij-powtórz ...................................................................................793 21.4. Aspekty implementacyjne ..................................................................................................................796 21.5. Interfejs użytkownika dla operacji cofania i powtarzania ..................................................................800 21.6. Analiza ...............................................................................................................................................802 21.7. Bibliografia ........................................................................................................................................804 Ćwiczenia .....................................................................................................................................................805 22. Jak odnaleźć klasy? ..........................................................................................809 22.1. Analiza dokumentu z wymogami .......................................................................................................810 22.2. Oznaki zagrożenia ..............................................................................................................................816 22.3. Ogólna heurystyka odnajdywania klas ...............................................................................................822 22.4. Inne źródła klas ..................................................................................................................................826 22.5. Wielokrotne zastosowanie ..................................................................................................................832 22.6. Metoda uzyskiwania klas ...................................................................................................................833 22.7. Kluczowe pojęcia wprowadzone w tym rozdziale .............................................................................835 22.8. Bibliografia ........................................................................................................................................835 Ćwiczenia .....................................................................................................................................................836 23. Zasady projektowania klas ..............................................................................839 23.1. Skutki uboczne w funkcjach ...............................................................................................................840 23.2. Ile argumentów powinna mieć cecha? ................................................................................................856 23.3. Rozmiar klasy — metoda listy zakupów ............................................................................................863 23.4. Aktywne struktury danych .................................................................................................................867 23.5. Cechy eksportowane selektywnie .......................................................................................................892 23.6. Postępowanie w przypadkach nietypowych .......................................................................................893 23.7. Ewolucja klasy — klauzula OBSOLETE ...........................................................................................898 23.8. Dokumentowanie klasy i systemu ......................................................................................................899 23.9. Kluczowe pojęcia wprowadzone w tym rozdziale .............................................................................902 23.10. Bibliografia ........................................................................................................................................902 Ćwiczenia .....................................................................................................................................................903 10 SPIS TREŚCI 24. Prawidłowe stosowanie dziedziczenia .............................................................907 24.1. Jak używać dziedziczenia? .................................................................................................................907 24.2. Kupić czy odziedziczyć? ....................................................................................................................910 24.3. Przykład zastosowania — technika uchwytów ...................................................................................916 24.4. Taksomania ........................................................................................................................................919 24.5. Zastosowanie dziedziczenia — taksonomia taksonomii .....................................................................921 24.6. Jeden czy więcej mechanizmów? .......................................................................................................933 24.7. Dziedziczenie podtypów i ukrywanie u potomków ............................................................................935 24.8. Dziedziczenie implementacji .............................................................................................................944 24.9. Dziedziczenie udogodnień .................................................................................................................947 24.10. Wielość kryteriów i dziedziczenie perspektywy ................................................................................952 24.11. Jak opracowywać struktury dziedziczenia? ........................................................................................958 24.12. Podsumowanie — prawidłowe stosowanie dziedziczenia ..................................................................962 24.13. Kluczowe pojęcia wprowadzone w tym rozdziale .............................................................................963 24.14. Bibliografia ........................................................................................................................................964 24.15. Dodatek — historia taksonomii ..........................................................................................................964 Ćwiczenia .....................................................................................................................................................970 25. Przydatne techniki ............................................................................................973 25.1. Filozofia projektowania ......................................................................................................................973 25.2. Klasy ..................................................................................................................................................974 25.3. Techniki dziedziczenia .......................................................................................................................976 26. Poczucie stylu ....................................................................................................979 26.1. Kwestie kosmetyczne mają znaczenie! ..............................................................................................979 26.2. Dobór odpowiednich nazw .................................................................................................................983 26.3. Stałe ...................................................................................................................................................989 26.4. Komentarze nagłówkowe i klauzule indeksujące ...............................................................................991 26.5. Układ i prezentacja tekstu ..................................................................................................................997 26.6. Czcionki ...........................................................................................................................................1006 26.7. Bibliografia ......................................................................................................................................1008 Ćwiczenia ...................................................................................................................................................1008 27. Analiza obiektowa ...........................................................................................1011 27.1. Cele analizy ......................................................................................................................................1012 27.2. Zmienna natura analizy ....................................................................................................................1014 27.3. Wkład technologii obiektowej ..........................................................................................................1015 27.4. Programowanie stacji telewizyjnej ...................................................................................................1016 27.5. Użyteczność analizy — wielokrotność postaci ................................................................................1023 27.6. Metody analizy .................................................................................................................................1027 27.7. Notacja obiektów biznesowych — NOB ..........................................................................................1030 27.8. Bibliografia ......................................................................................................................................1033 SPIS TREŚCI 11 28. Proces tworzenia oprogramowania ...............................................................1035 28.1. Klastry ..............................................................................................................................................1035 28.2. Inżynieria symultaniczna ..................................................................................................................1036 28.3. Kroki i zadania .................................................................................................................................1038 28.4. Klastrowy model cyklu życia oprogramowania ...............................................................................1039 28.5. Uogólnienie ......................................................................................................................................1040 28.6. Jednolitość i odwracalność ...............................................................................................................1043 28.7. Wśród nas wszystko jest twarzą .......................................................................................................1046 28.8. Kluczowe pojęcia wprowadzone w tym rozdziale ...........................................................................1047 28.9. Bibliografia ......................................................................................................................................1047 29. Nauczanie .........................................................................................................1049 29.1. Szkolenia przemysłowe ....................................................................................................................1049 29.2. Kursy wprowadzające ......................................................................................................................1052 29.3. Inne kursy .........................................................................................................................................1056 29.4. W kierunku nowych sposobów nauczania tworzenia oprogramowania ...........................................1058 29.5. Plan wydziału związany z obiektowością ........................................................................................1062 29.6. Kluczowe zagadnienia wprowadzone w rozdziale ...........................................................................1064 29.7. Bibliografia ......................................................................................................................................1064 Część V Zagadnienia zaawansowane 1067 30. Współbieżność, rozproszenie, klient-serwer i internet ................................1069 30.1. Krótkie podsumowanie ....................................................................................................................1070 30.2. Narodziny współbieżności ...............................................................................................................1071 30.3. Od procesów do obiektów ................................................................................................................1075 30.4. Wykonywanie współbieżne ..............................................................................................................1083 30.5. Kwestie synchronizacji ....................................................................................................................1097 30.6. Dostęp do obiektów niezależnych ....................................................................................................1103 30.7. Warunki oczekiwania .......................................................................................................................1112 30.8. Żądania obsługi w trybie specjalnym ...............................................................................................1121 30.9. Przykłady .........................................................................................................................................1126 30.10. W kierunku reguły dowodzenia poprawności ..................................................................................1144 30.11. Podsumowanie przedstawionego mechanizmu współbieżności .......................................................1146 30.12. Analiza .............................................................................................................................................1149 30.13. Kluczowe pojęcia wprowadzone w tym rozdziale ...........................................................................1154 30.14. Bibliografia ......................................................................................................................................1155 Ćwiczenia ...................................................................................................................................................1157 31. Trwałość obiektów i bazy danych ..................................................................1161 31.1. Trwałość jako element języka ..........................................................................................................1161 31.2. Granice implementacji trwałości ......................................................................................................1163 12 SPIS TREŚCI 31.3. Ewolucja schematu ...........................................................................................................................1165 31.4. Od trwałości do baz danych .............................................................................................................1172 31.5. Współpraca obiektowo-relacyjna .....................................................................................................1173 31.6. Podstawy obiektowych baz danych ..................................................................................................1176 31.7. Systemy obiektowych baz danych — przykłady ..............................................................................1182 31.8. Analiza — pozaobiektowe bazy danych ..........................................................................................1185 31.9. Kluczowe pojęcia wprowadzone w tym rozdziale ...........................................................................1187 31.10. Bibliografia ......................................................................................................................................1188 Ćwiczenia ...................................................................................................................................................1189 32. Wybrane techniki obiektowe wykorzystywane w interaktywnych aplikacjach z graficznym interfejsem użytkownika ....................................1191 32.1. Potrzebne narzędzia .........................................................................................................................1192 32.2. Przenośność i adaptacja do platformy ..............................................................................................1195 32.3. Abstrakcje graficzne .........................................................................................................................1197 32.4. Mechanizmy interakcji .....................................................................................................................1200 32.5. Obsługa zdarzeń ...............................................................................................................................1202 32.6. Model matematyczny .......................................................................................................................1206 32.7. Bibliografia ......................................................................................................................................1206 Część VI Zastosowanie metody w różnych językach i środowiskach programowania 33. Programowanie obiektowe i Ada ...................................................................1209 33.1. Trochę historii ..................................................................................................................................1210 33.2. Pakiety ..............................................................................................................................................1211 33.3. Implementacja stosu .........................................................................................................................1212 33.4. Ukrywanie reprezentacji ..................................................................................................................1216 33.5. Wyjątki .............................................................................................................................................1218 33.6. Zadania .............................................................................................................................................1222 33.7. Ada 95 ..............................................................................................................................................1223 33.8. Kluczowe pojęcia wprowadzone w tym rozdziale ...........................................................................1228 33.9. Bibliografia ......................................................................................................................................1228 Ćwiczenia ...................................................................................................................................................1229 34. Emulacja technologii obiektowej w środowiskach nieobiektowych ...........1231 34.1. Poziomy obsługi koncepcji obiektowych .........................................................................................1232 34.2. Programowanie obiektowe w Pascalu? ............................................................................................1233 34.3. Fortran ..............................................................................................................................................1234 34.4. Programowanie obiektowe i język C ................................................................................................1239 34.5. Bibliografia ......................................................................................................................................1245 Ćwiczenia ...................................................................................................................................................1246 1207 SPIS TREŚCI 13 35. Od Simuli do Javy: główne języki i środowiska obiektowe ........................1247 35.1. Simula ..............................................................................................................................................1248 35.2. Smalltalk ..........................................................................................................................................1261 35.3. Rozszerzenia języka Lisp .................................................................................................................1265 35.4. Rozszerzenia języka C .....................................................................................................................1267 35.5. Java ..................................................................................................................................................1271 35.6. Inne języki obiektowe ......................................................................................................................1272 35.7. Bibliografia ......................................................................................................................................1273 Ćwiczenia ...................................................................................................................................................1275 1277 Część VII W praktyce 36. Środowisko obiektowe ....................................................................................1279 36.1. Komponenty .....................................................................................................................................1280 36.2. Język ................................................................................................................................................1280 36.3. Technologia kompilacji ....................................................................................................................1281 36.4. Narzędzia .........................................................................................................................................1285 36.5. Biblioteki ..........................................................................................................................................1289 36.6. Mechanizmy interfejsu .....................................................................................................................1290 36.7. Bibliografia ......................................................................................................................................1297 Epilog ujawnia język ......................................................................................1299 Dodatki A Wybrane klasy bibliotek Base .......................................................................1303 1301 B Generyczność a dziedziczenie ........................................................................1355 B.1. Generyczność ....................................................................................................................................1356 B.2. Dziedziczenie ....................................................................................................................................1361 B.3. Emulacja dziedziczenia za pomocą generyczności ............................................................................1363 B.4. Emulacja generyczności za pomocą dziedziczenia ............................................................................1364 B.5. Łączenie generyczności z dziedziczeniem .........................................................................................1372 B.6. Kluczowe pojęcia wprowadzone w tym dodatku ..............................................................................1376 B.7. Bibliografia ........................................................................................................................................1376 Ćwiczenia ...................................................................................................................................................1377 14 SPIS TREŚCI C Zasady, reguły, nakazy i definicje .................................................................1379 D Określenia stosowane w technice obiektowej ...............................................1385 E Bibliografia ......................................................................................................1397 E.1. Prace innych autorów ........................................................................................................................1397 E.2. Prace autora książki ...........................................................................................................................1416 Skorowidz ........................................................................................................ 1421 1 JAKOŚĆ OPROGRAMOWANIA Słowo inżynieria nieodzownie kojarzy się z jakością. Inżynieria oprogramowania to tworzenie wysokich jakościowo programów. Ta książka opisuje techniki, które poten- cjalnie mogą przyczynić się do znacznego podniesienia jakości aplikacji komputerowych. Zanim zacznę je omawiać, muszę napisać, w jakim celu zostały wymyślone. Jakość oprogramowania najlepiej pojmować jako sumę wielu czynników. W tym rozdziale opi- szę kilka z nich, zidentyfikuję obszary, jakie najpilniej wymagają usprawnień, i wskażę kierunek, w którym wspólnie będziemy szukać rozwiązań w trakcie dalszej lektury. 1.1. CZYNNIKI ZEWNĘTRZNE I WEWNĘTRZNE Wszyscy chcemy, aby nasze oprogramowanie było szybkie, niezawodne, łatwe w obsłu- dze, czytelne, modułowe, sensownie skonstruowane itd. Tyle tylko, że te przymiotniki opisują dwa różne rodzaje zalet. Po jednej stronie mamy zalety, takie jak szybkość czy łatwość obsługi, których obecność lub brak może z łatwością stwierdzić każdy użytkownik. Tego rodzaju właści- wości możemy nazwać zewnętrznymi czynnikami decydującymi o jakości. Pod pojęciem „użytkownicy” należy rozumieć nie tylko osoby, które będą fizycznie korzystały z gotowych programów (na przykład pracownik linii lotniczych obsługujący system rezerwacji lotów), ale także decydentów, którzy podjęli decyzję o ich zakupie bądź zlecili ich opracowanie (analogicznie dyrektor linii lotniczych, którego uprawnienia na to pozwalają). Tak więc taka właściwość jak łatwość, z jaką oprogramowanie daje się dostosowywać do zmian w specyfikacji (w dalszej części tego rozdziału nazywana rozszerzalnością), jest zaliczana do kategorii czynników zewnętrznych, mimo iż „użytkownicy końcowi”, tacy jak pracownik dokonujący rezerwacji, mogą nie być nią bezpośrednio zainteresowani. Inne możliwe zalety programu komputerowego, takie jak czytelność czy modu- łowość, zaliczamy do czynników wewnętrznych, ponieważ są one dostrzegalne jedynie dla informatyków mających dostęp do kodu źródłowego programu. 30 ROZDZIAŁ 1. (cid:122) JAKOŚĆ OPROGRAMOWANIA W ostatecznym rozrachunku liczą się tylko czynniki zewnętrzne. Gdy korzystam z przeglądarki internetowej lub mieszkam w pobliżu elektrowni atomowej sterowanej przez program komputerowy, tak naprawdę nie obchodzi mnie to, czy jego kod źró- dłowy jest modularny i czytelny. Ważne, żeby obrazki w przeglądarce nie wczyty- wały się godzinami, a błędne dane wejściowe nie mogły doprowadzić do wysadzenia elektrowni. Jednak kluczem do osiągnięcia satysfakcjonujących czynników zewnętrz- nych są czynniki wewnętrzne. Aby użytkownicy mogli cieszyć się widocznymi ozna- kami jakości aplikacji, ich projektanci i implementatorzy muszą stosować techniki gwa- rantujące wysoką jakość wewnętrzną. W kolejnych rozdziałach przedstawiam zbiór współczesnych technik pozwalają- cych na uzyskanie właśnie wewnętrznej jakości aplikacji. Czytając ten rozdział, nie powinieneś jednak tracić z oczu szerszego obrazu. Techniki wewnętrzne nie są naszym celem same w sobie. Są to jedynie środki, za pomocą których możemy uzyskać wysoką jakość zewnętrzną tworzonych aplikacji. Dlatego też musimy zacząć od omówienia czynników zewnętrznych. Przeznaczyłem na to pozostałą część tego rozdziału. 1.2. PRZEGLĄD CZYNNIKÓW ZEWNĘTRZNYCH Poniżej opisuję najważniejsze czynniki zewnętrzne decydujące o jakości, które powinny być obecne w każdym programie komputerowym. Doprowadzenie do takiego stanu jest głównym celem programowania zorientowanego obiektowo. Poprawność Definicja poprawności Poprawność to zdolność programów komputerowych do wykonywania dokładnie tych zadań, które im powierzono i które zdefiniowano w ich specyfikacjach. Poprawność jest zdecydowanie najważniejszym czynnikiem. Jeżeli system nie robi tego, czego się po nim oczekuje, wszystko inne — czy jest szybki, czy ma przyjemny interfejs użytkownika itd. — nie ma większego znaczenia. Łatwo o niej pisać, ale znacznie trudniej ją osiągnąć. Już pierwszy krok na dro- dze do poprawności jest trudny. Trzeba bowiem precyzyjnie określić wymagania sta- wiane systemowi. Techniki stosowane w celu zapewnienia poprawności zazwyczaj odnoszą się je- dynie do pewnego obszaru systemu. Poważne współczesne programy komputerowe, nawet te mniejsze, odnoszą się do zagadnień z tak wielu dziedzin, że niemożliwe byłoby zagwarantowanie ich poprawności po pr
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Programowanie zorientowane obiektowo
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: