programowanie zorientowane obiektowo scan.pdf

(16521 KB) Pobierz
IDZ DO
PRZYK£ADOW Y ROZDZIA£
Programowanie
zorientowane obiektowo
SPIS TREŒCI
KATALOG KSI¥¯EK
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
Format: B5, stron: 1464
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
DODAJ DO KOSZYKA
Poznaj regu³y projektowania i programowania obiektowego
• Elementy techniki obiektowej
Metodyka tworzenia oprogramowania
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.
Podstawowe elementy projektowania obiektowego
Wielokrotne wykorzystywanie kodu
Analiza obiektowa
Abstrakcyjne typy danych
Klasy i obiekty
Zarz¹dzanie pamiêci¹
Mechanizmy dziedziczenia
Obs³uga wyj¹tków
Metodyka projektowania obiektowego
Programowanie wspó³bie¿ne
Obiektowe bazy danych
Zastosowanie technik obiektowych w ró¿nych jêzykach programowania
Wykorzystaj techniki obiektowe i popraw jakoϾ tworzonego przez siebie oprogramowania
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
ONOWOŒCIACH
ZAMÓW CENNIK
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
780817336.033.png 780817336.034.png 780817336.035.png 780817336.036.png 780817336.001.png 780817336.002.png 780817336.003.png 780817336.004.png 780817336.005.png 780817336.006.png 780817336.007.png 780817336.008.png 780817336.009.png 780817336.010.png 780817336.011.png 780817336.012.png 780817336.013.png 780817336.014.png 780817336.015.png 780817336.016.png
 
S PIS TREŚCI
O Autorze .............................................................................................................15
Wstęp ....................................................................................................................17
Część I Podstawy
27
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
780817336.017.png 780817336.018.png 780817336.019.png 780817336.020.png 780817336.021.png 780817336.022.png 780817336.023.png 780817336.024.png
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
Część III Techniki obiektowe
209
7.
Klasy — struktura statyczna ...........................................................................211
7.1. Obiekty nie są najważniejsze ...............................................................................................................211
7.2. Unikanie typowych nieporozumień ......................................................................................................212
780817336.025.png 780817336.026.png 780817336.027.png 780817336.028.png
 
5
SPIS TREŚCI
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
780817336.029.png 780817336.030.png
 
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
780817336.031.png 780817336.032.png
 

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin