Struktury danych i techniki obiektowe na przykladzie Javy 50.pdf

(1047 KB) Pobierz
Struktury danych i techniki obiektowe na przykładzie Javy 5.0
IDZ DO
PRZYK£ADOW Y ROZDZIA£
Struktury danych i techniki
obiektowe na przyk³adzie
Javy 5.0
SPIS TREŒCI
KATALOG KSI¥¯EK
KATALOG ONLINE
Autorzy: Elliot Koffman, Paul Wolfgang
T³umaczenie: Rafa³ Joñca, Tomasz ¯mijewski
ISBN: 83-246-0089-2
Tytu³ orygina³u: Objects, Abstraction, Data
Format: B5, stron: 936
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
DODAJ DO KOSZYKA
Przy tworzeniu systemów informatycznych najwa¿niejsze zadania wykonuje siê,
zanim powstanie pierwszy fragment kodu Ÿród³owego. Wymogi stawiane wspó³czesnym
aplikacjom powoduj¹, ¿e in¿ynieria oprogramowania staje siê kwesti¹ kluczow¹.
Opracowanie odpowiedniego projektu oraz w³aœciwy dobór technologii i metodologii
zapewniaj¹ szybk¹ i efektywn¹ pracê nad systemem. Niezwykle wa¿ne jest poznanie
dostêpnych w jêzyku Java struktur danych i umiejêtnoœæ ich wykorzystania.
Prawid³owo dobrana struktura danych znacznie przyspiesza nie tylko implementacjê
aplikacji, ale równie¿ dzia³anie gotowego systemu.
Ksi¹¿ka „Struktury danych i techniki obiektowe na przyk³adzie Javy 5.0” przedstawia
podstawowe struktury danych i sposoby ich wykorzystania podczas programowania
obiektowego. Wszystkie wiadomoœci zosta³y zaprezentowane z uwzglêdnieniem regu³
nowoczesnej in¿ynierii oprogramowania. Czytaj¹c kolejne rozdzia³y ksi¹¿ki, poznasz
najlepsze zastosowania ró¿nych struktur danych oraz wady i zalety ich implementacji.
Przede wszystkim jednak zrozumiesz potrzebê stosowania tak wielu struktur danych.
Cykl ¿ycia oprogramowania
Zastosowanie jêzyka UML w projektowaniu systemów
Obs³uga b³êdów i wyj¹tków
Testowanie oprogramowania
Dziedziczenie i hierarchia klas
Listy jedno- i dwukierunkowe
Interfejs Collection
Stosy i kolejki
Algorytmy rekurencyjne
Sortowanie danych
Drzewa wyszukiwania
Grafy
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
Po przeczytaniu tej ksi¹¿ki zrozumiesz zasadê:
„Pomyœl, a dopiero potem pisz kod”
400259516.002.png 400259516.003.png 400259516.004.png 400259516.005.png
Przedmowa ..................................................................................... 17
Rozdział 1. Wprowadzenie do projektowania oprogramowania ............................ 29
1.1. Cykl życia oprogramowania ..............................................................................30
Modele cyklu życia oprogramowania ...................................................................31
Działania związane z cyklem życia oprogramowania ..........................................33
Specyfikacja wymagań .........................................................................................34
Analiza ..................................................................................................................35
Projektowanie .......................................................................................................36
Ćwiczenia do podrozdziału 1.1 .............................................................................38
1.2. Abstrakcja pomaga zarządzać złożonością ......................................................39
Abstrakcja proceduralna .......................................................................................39
Abstrakcja danych .................................................................................................40
Ukrywanie informacji ...........................................................................................40
Ćwiczenia do podrozdziału 1.2 .............................................................................41
1.3. Abstrakcyjne typy danych, interfejsy, warunki wstępne i końcowe ..............42
Interfejsy ...............................................................................................................43
Klauzula implements ............................................................................................45
Deklaracja zmiennej będącej typem interfejsu .....................................................45
Interfejs dla klasy książki telefonicznej ................................................................46
Komentarze Javadoc .............................................................................................46
Kontrakty i interfejsy ............................................................................................47
Warunki początkowe i końcowe ...........................................................................47
Ćwiczenia do podrozdziału 1.3 .............................................................................48
1.4. Analiza wymagań, przypadki użycia i diagramy sekwencji ...........................49
ANALIZA PRZYPADKU — projektowanie programu książki telefonicznej ....50
Ćwiczenia do podrozdziału 1.4 .............................................................................55
1.5. Projektowanie książki telefonicznej bazującej na tablicy ...............................56
ANALIZA PRZYPADKU — projektowanie programu książki telefonicznej
(kontynuacja) ......................................................................................................56
Ćwiczenia do podrozdziału 1.5 .............................................................................62
1.6. Implementacja i testowanie książki telefonicznej bazującej na tablicy .........62
ANALIZA PRZYPADKU — projektowanie programu książki telefonicznej
(kontynuacja) ......................................................................................................62
Ćwiczenia do podrozdziału 1.6 .............................................................................69
400259516.001.png
4
Struktury danych i techniki obiektowe na przykładzie Javy 5.0
1.7. Dwie klasy implementujące interfejs PDUserInterface ...................................69
ANALIZA PRZYPADKU — projektowanie programu książki telefonicznej
(kontynuacja) ......................................................................................................69
Ćwiczenia do podrozdziału 1.7 .............................................................................80
Podsumowanie rozdziału ...............................................................................................80
Rozdział 2. Poprawność i wydajność programów ............................................... 87
2.1. Defekty i błędy w programach ...........................................................................88
Błędy składniowe ..................................................................................................89
Błędy czasu wykonania i wyjątki .........................................................................90
Błędy logiczne ......................................................................................................94
Ćwiczenia do podrozdziału 2.1 .............................................................................95
2.2. Hierarchia klas wyjątków ..................................................................................95
Klasa Throwable ...................................................................................................96
Wyjątki weryfikowane i nieweryfikowane ...........................................................96
Ćwiczenia do podrozdziału 2.2 .............................................................................97
2.3. Wyłapywanie i obsługa wyjątków .....................................................................99
Wyjątki niewyłapane ............................................................................................99
Sekwencja try-catch-finally ..................................................................................99
Ćwiczenia do podrozdziału 2.3 ...........................................................................106
2.4. Zgłaszanie wyjątków .........................................................................................106
Klauzula throws ..................................................................................................106
Instrukcja throw ..................................................................................................108
Wyłapywanie wyjątków w programie książki telefonicznej ..............................111
Ćwiczenia do podrozdziału 2.4 ...........................................................................113
2.5. Testowanie programów ....................................................................................114
Strukturalne ścieżki przejścia .............................................................................115
Poziomy i rodzaje testów ....................................................................................115
Przygotowanie do testów ....................................................................................117
Wskazówki dotyczące testowania programów ...................................................118
Przygotowanie danych testowych .......................................................................119
Testowanie warunków granicznych ....................................................................119
Kto wykonuje testy? ...........................................................................................122
Namiastki ............................................................................................................123
Programy testujące ..............................................................................................124
Testowanie klasy .................................................................................................124
Wykorzystanie systemu testującego ...................................................................125
Testy regresyjne ..................................................................................................127
Testy integracyjne ...............................................................................................128
Ćwiczenia do podrozdziału 2.5 ...........................................................................128
2.6. Usuwanie błędów z programów .......................................................................129
Wykorzystanie programu uruchomieniowego ....................................................130
Ćwiczenia do podrozdziału 2.6 ...........................................................................134
2.7. Rozważania na temat programów: asercje i niezmienniki pętli ...................134
Asercje ................................................................................................................135
Niezmienniki pętli ...............................................................................................135
Rozszerzenie tematu — instrukcja assert języka Java ........................................137
Ćwiczenia do podrozdziału 2.7 ...........................................................................138
2.8. Wydajność algorytmów ....................................................................................138
Notacja dużego O ................................................................................................141
Porównanie wydajności ......................................................................................145
Spis treści
5
Algorytmy o złożoności wykładniczej ................................................................146
Ćwiczenia do podrozdziału 2.8 ...........................................................................147
Podsumowanie rozdziału .............................................................................................148
Rozdział 3. Dziedziczenie i hierarchie klas ....................................................... 157
3.1. Wprowadzenie do dziedziczenia i hierarchii klas ..........................................158
Związki „jest” i „zawiera” ..................................................................................160
Klasa bazowa i podklasa .....................................................................................161
Wykorzystanie słowa kluczowego this ...............................................................162
Inicjalizacja pól danych podklasy .......................................................................163
Konstruktor bezparametrowy ..............................................................................164
Pola chronione klasy bazowej .............................................................................164
Ćwiczenia do podrozdziału 3.1 ...........................................................................165
3.2. Przeciążanie metod, przesłanianie metod i polimorfizm ...............................166
Przesłanianie metod ............................................................................................166
Przeciążanie metod .............................................................................................168
Polimorfizm ........................................................................................................169
Ćwiczenia do podrozdziału 3.2 ...........................................................................171
3.3. Klasy abstrakcyjne, przypisanie i rzutowanie w hierarchii klas ..................172
Referencje do obiektów rzeczywistych ..............................................................174
Klasy abstrakcyjne i interfejsy ............................................................................174
Klasa abstrakcyjna Number i klasy opakowujące typy podstawowe .................174
Podsumowanie cech klas konkretnych, klas abstrakcyjnych i interfejsów .........175
Ćwiczenia do podrozdziału 3.3 ...........................................................................175
3.4. Klasa Object, rzutowanie i klonowanie ..........................................................177
Metoda toString() ................................................................................................177
Dopuszczalne operacje określa typ zmiennej referencyjnej ...............................177
Rzutowanie w hierarchii klas ..............................................................................178
Metoda Object.equals() .......................................................................................182
Klonowanie .........................................................................................................183
Klonowanie struktury danych .............................................................................187
Ćwiczenia do podrozdziału 3.4 ...........................................................................188
3.5. Dziedziczenie wielobazowe, stosowanie wielu interfejsów i delegacja .........189
Wykorzystanie wielu interfejsów do emulacji dziedziczenia wielobazowego ...189
Implementacja wielokrotnego użycia dzięki delegacji .......................................191
Ćwiczenia do podrozdziału 3.5 ...........................................................................192
3.6. Pakiety i widoczność .........................................................................................193
Pakiety .................................................................................................................193
Środowisko bez deklaracji nazwy pakietu ..........................................................193
Widoczność w ramach pakietu ...........................................................................194
Widoczność pozwala wspomóc hermetyzację ....................................................194
Ćwiczenia do podrozdziału 3.6 ...........................................................................195
3.7. Hierarchia klas kształtu ...................................................................................196
ANALIZA PRZYPADKU — rysowanie figur geometrycznych .......................196
Ćwiczenia do podrozdziału 3.7 ...........................................................................212
3.8. Fabryki obiektów ..............................................................................................212
ANALIZA PRZYPADKU — obliczanie pól i obwodów figur
geometrycznych ................................................................................................213
Ćwiczenia do podrozdziału 3.8 ...........................................................................215
6
Struktury danych i techniki obiektowe na przykładzie Javy 5.0
Podsumowanie rozdziału .............................................................................................215
Rozdział 4. Listy i interfejs Collection ............................................................. 223
4.1. Interfejs List i klasa ArrayList ........................................................................224
Klasa ArrayList ...................................................................................................225
Kolekcje sparametryzowane ...............................................................................227
Specyfikacja klasy ArrayList ..............................................................................229
Ćwiczenia do podrozdziału 4.1 ...........................................................................230
4.2. Zastosowania ArrayList ...................................................................................230
Powrót do programu książki telefonicznej .........................................................231
Ćwiczenia do podrozdziału 4.2 ...........................................................................232
4.3. Implementacja klasy ArrayList .......................................................................233
Konstruktor klasy KWArrayList<E> ..................................................................234
Metoda add(E anEntry) .......................................................................................234
Metoda add(int index, E anEntry) .......................................................................235
Metody set() i get() .............................................................................................236
Metoda remove() .................................................................................................237
Metoda reallocate() .............................................................................................237
Implementacja KWArrayList jako klasy bez parametryzacji .............................238
Wydajność KWArrayList ...................................................................................238
Klasa Vector ........................................................................................................238
Ćwiczenia do podrozdziału 4.3 ...........................................................................239
4.4. Listy jednokierunkowe i dwukierunkowe ......................................................239
Węzeł listy ..........................................................................................................241
Łączenie węzłów .................................................................................................243
Klasa listy jednokierunkowej ..............................................................................243
Wstawienie węzła ...............................................................................................244
Usunięcie węzła ..................................................................................................244
Przejście przez listę .............................................................................................245
Listy dwukierunkowe ..........................................................................................246
Klasa listy dwukierunkowej ................................................................................248
Listy cykliczne ....................................................................................................249
Ćwiczenia do podrozdziału 4.4 ...........................................................................250
4.5. Klasa LinkedList oraz interfejsy Iterator, ListIterator i Iterable ................252
Klasa LinkedList .................................................................................................252
Iterator .................................................................................................................252
Interfejs Iterator ..................................................................................................253
Interfejs ListIterator ............................................................................................255
Porównanie Iterator i ListIterator ........................................................................258
Interfejs ListIterator i indeks ...............................................................................258
Rozszerzona pętla for ..........................................................................................258
Interfejs Iterable ..................................................................................................259
Ćwiczenia do podrozdziału 4.5 ...........................................................................259
4.6. Implementacja klasy listy dwukierunkowej ...................................................260
Implementacja metod klasy KWLinkedList .......................................................261
Klasa implementująca interfejs ListIterator ........................................................262
Klasy wewnętrzne — statyczne i niestatyczne ...................................................268
Ćwiczenia do podrozdziału 4.6 ...........................................................................269
4.7. Zastosowania klasy LinkedList .......................................................................269
ANALIZA PRZYPADKU — przechowywanie uporządkowanej listy .............270
Ćwiczenia do podrozdziału 4.7 ...........................................................................276

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin