Eckel B. - Thinking in Java. Edycja polska. Wydanie IV.pdf

ilIùiUu g .. -------- ...

Spis treści Rozdział 1. Rozdział 2. Przedmowa 19 Wprowadzenie Wprowadzenie w świat obiektów ........ Postępująca abstrakcja........................................... Obiekt posiada interfejs......................................... Obiekt dostarcza usługi ......................................... Ukrywanie implementacji ..................................... Wielokrotne wykorzystanie implementacji........... Dziedziczenie ........................................................ „Bycie czymś” a „bycie podobnym do czegoś” Wymienialność obiektów z użyciem polimorfizmu ... Hierarchia z pojedynczym korzeniem Kontenery ................................................. Typy parametryzowane (typy ogólne) Tworzenie obiektów i czas ich życia............ Obsługa wyjątków — eliminowanie błędów Współbieżność.............................................. Java i Internet ............................................... Czymjest sieć WWW? .......................... Programowanie po stronie klienta . Programowanie po stronie serwera Podsumowanie..................................... .. 29 .. 37 ....38 ....40 .42 .43 .45 .48 .49 .52 .53 .54 .55 .57 .57 .58 .58 .60 .65 .65 Wszystko jest obiektem ..............................................................67 Dostęp do obiektów poprzez referencje..................................................................................67 Wszystkie obiekty trzeba stworzyć .........................................................................................68 Gdzie przechowujemy dane ..............................................................................................69 Przypadek specjalny: typy podstawowe............................................................................70 .71 „72 „72 „73 „74 .74 ...76 ...76 Tablice w Javie................................ Nigdy nie ma potrzeby niszczenia obiektu Zasięg.............................................. Zasięg obiektów .............................. Własne typy danych — słowo class Pola i metody............................ Metody, argumenty i wartości zwracane . Lista argumentów.................

6 Thinking in Java. Edycja polska Rozdział 3. Rozdział 4. Tworzenie programu w Javic...................................................................................................78 Widoczność nazw....................................................................................................................78 Wykorzystanie innych komponentów...............................................................................78 Słowo kluczowe static.......................................................................................................79 Twój pierwszy program w Javie..............................................................................................81 Kompilacja i uruchomienie...............................................................................................83 Komentarze oraz dokumentowanie kodu................................................................................ 84 Dokumentacja w komentarzach ........................................................................................ 84 Składnia.............................................................................................................................85 Osadzony HTML .............................................................................................................. 86 Niektóre znaczniki dokumentacyjne.................................................................................86 Przykład dokumentowania kodu.......................................................................................88 Styl programowania................................................................................................................. 89 Podsumowanie.........................................................................................................................90 Ćwiczenia................................................................................................................................90 Operatory ................................................................................ 93 Prosta instrukcja wyjścia.........................................................................................................93 Używanie operatorów Javy .....................................................................................................94 Kolejność operatorów..............................................................................................................95 Przypisanie ..............................................................................................................................95 Tworzenie nazw w wywołaniach metod...........................................................................97 Operatory matematyczne.........................................................................................................98 Jednoargumentowe operatory minus i plus..................................................................... 100 Operatory zwiększania i zmniejszania .................................................................................. 100 Operatory relacji.................................................................................................................... 101 Sprawdzanie równości obiektów..................................................................................... 101 Operatory logiczne ...............................................................................................................103 Skracanie obliczenia wyrażenia logicznego.................................................................... 104 Literały ...................................................................................................................................105 Zapis wykładniczy ...........................................................................................................106 Operatory bitowe................................................................................................................... 108 Operatory przesunięć..............................................................................................................109 Operator trójargumentowy if-else ..........................................................................................112 Operatory + i += dla klasy String.......................................................................................... 113 Najczęstsze pułapki przy używaniu operatorów ..................................................................114 Operatory' rzutowania............................................................................................................ 115 Obcinanie a zaokrąglanie ...............................................................................................116 Promocja typu ..................................................................................................................117 W Javic nie ma „sizeof’ .......................................................................................................117 Kompendium operatorów.......................................................................................................118 Podsumowanie........................................................................................................................126 Sterowanie przebiegiem wykonania ............................................. 127 Prawda i fałsz .......................................................................................................................127 if-else......................................................................................................................................128 Iteracja................................................................................................................................... 129 do-while........................................................................................................................... 129 fo r.................................................................................................................................... 130 Operator przecinka.......................................................................................................... 131 Składnia foreach .................................................................................................................... 132 retum...................................................................................................................................... 134 break i continue ..................................................................................................................... 135 Niesławne „goto” ................................................................... 136 switch............................................................................................................ 140 Podsumowanie................................................................................................... 142

Spis treści 7 Rozdział 5. Rozdział 6. Rozdział 7. Inicjalizacja i sprzątanie ............................................................ 143 GiwmtoHmamffl/m&fNzi&łms&ziitor.................. ..........................MS Przeciążanie metod...............................................................................................................145 Rozróżnianie przeciążonych metod .............................................................................. 147 Przeciążanie a typy podstawowe....................................................................................148 Przeciążanie przez wartości zwracane ...........................................................................151 Konstruktory domyślne ........................................................................................................152 Słowo kluczowe this.............................................................................................................153 Wywoływanie konstruktorów z konstruktorów.............................................................155 Znaczenie słowa static....................................................................................................157 Sprzątanie: finalizacja i odśmiecanie pamięci......................................................................157 Do czego służy finalize() ...............................................................................................158 Musisz przeprowadzić sprzątanie ..................................................................................159 Warunek zakończenia ....................................................................................................160 Jak działa odśmiecacz pamięci.......................................................................................161 Inicjalizacja składowych ......................................................................................................164 Określanie sposobu inicjalizacji.....................................................................................166 Inicjalizacja w konstruktorze................................................................................................167 Kolejność inicjalizacji....................................................................................................167 Inicjalizacja zmiennych statycznych.............................................................................. 168 Jawna inicjalizacja statyczna.......................................................................................... 171 Inicjalizacja egzemplarza...............................................................................................172 Inicjalizacjatablic ............................................................. ,...................................... 113 Zmienne listy argumentów............................................................................................ 177 Typy wyliczeniowe ....................................... 182 Podsumowanie....................................................................................................................... 185 Kontrola dostępu .....................................................................187 Pakiet—jednostka biblioteczna....................................................... 188 Organizacja kodu ...........................................................................................................189 Tworzenie unikatowych nazw pakietów......................................................................... 191 Własna biblioteka narzędziowa........................................................................................194 Wykorzystanie instrukcji import do zmiany zachowania..............................................196 Pułapka związana z pakietami .......................................................................................196 Modyfikatory dostępu w Javie .............................................................................................. 196 Dostęp pakietowy............................................................................................................ 197 public: dostęp do interfejsu............................................................................................. 198 private: nie dotykać!........................................................................................................ 199 protected: dostęp „na potrzeby” dziedziczenia ...............................................................200 Interfejs i implementacja.......................................................................................................202 Dostęp do klas .......................................................................................................................203 Podsumowanie.......................................................................................................................207 Wielokrotne wykorzystanie klas ..................................................209 Składnia kompozycji ..................................................... ,......... 210 Składnia dziedziczenia ..........................................................................................................212 Inicjalizacja klasy bazowej .............................................................................................214 Delegacje.................. 217 Łączenie kompozycji i dziedziczenia....................................................................................218 Zapewnienie poprawnego sprzątania..............................................................................220 Ukrywanie nazw................................ 223 Wybór między kompozycją a dziedziczeniem ......................................................................225 protected ...................................................................................... 226 Rzutowanie w górę.............. 227 Dlaczego „w górę” ..........................................................................................................228 Jeszcze o kompozycji i dziedziczeniu.............................................................................229

8 Thinking in Java. Edycja polska Słowo kluczowe finał............................................................................................................229 Zmienne finalne ..............................................................................................................229 Metody finalne ................................................................................................................233 Klasy finalne ...................................................................................................................235 Ostrożnie z deklaracją finał.............................................................................................236 Inicjalizacja i ładowanie klas.................................................................................................237 Inicjalizacja w przypadku dziedziczenia.........................................................................238 Podsumowanie.......................................................................................................................239 Rozdział 8 . Polim orfizm ......................................................................................................................241 Rzutowanie w górę razjeszcze..............................................................................................242 Zapominanie o typie obiektu...........................................................................................243 Mały trik................................................................................................................................244 Wiązanie wywołania metody..........................................................................................245 Uzyskiwanie poprawnego działania................................................................................245 Rozszerzalność............................................................................................................... 248 Pułapka: „przesłanianie” metod prywatnych ..................................................................251 Pułapka: statyczne pola i metody....................................................................................252 Konstruktory a polimorfizm..................................................................................................253 Kolejność wywołań konstruktorów.................................................................................253 Dziedziczenie a sprzątanie ..............................................................................................255 Zachowanie metod polimorficznych wewnątrz konstruktorów......................................260 Kowariancja typów zwracanych............................................................................................262 Projektowanie z użyciem dziedziczenia................................................................................263 Substytucja kontra rozszerzanie......................................................................................264 Rzutowanie w dół a identyfikacja typu w czasie wykonania..........................................265 Podsumowanie.......................................................................................................................267 Rozdział 9. Interfejsy........................................................................................................................... 269 Klasy i metody abstrakcyjne .................................................................................................269 Interfejsy................................................................................................................................273 Rozdzielenie zupełne.............................................................................................................276 „Dziedziczenie wielobazowe” w Javie..................................................................................280 Rozszerzanie interfejsu poprzez dziedziczenie .....................................................................283 Kolizje nazw podczas łączenia interfejsów.....................................................................284 Adaptowanie do interfejsu.....................................................................................................285 Pola w interfejsach ................................................................................................................287 Inicjalizacja pól interfejsów............................................................................................288 Zagnieżdżanie interfejsów.....................................................................................................289 Interfejsy a wytwórnie...........................................................................................................291 Podsumowanie.......................................................................................................................294 Rozdział 10. Klasy wewnętrzne ..........................................................................................................295 Tworzenie klas wewnętrznych ..............................................................................................295 Połączenie z klasą zewnętrzną...............................................................................................297 .this i mew..............................................................................................................................299 Klasy wewnętrzne a rzutowanie w górę................................................................................300 Klasy wewnetrzne w metodach i zasięgach ..........................................................................302 Anonimowe klasy wewnętrzne..............................................................................................304 Jeszcze o wzorcu Factory Method ..................................................................................308 Klasy zagnieżdżone ............................................................................................................310 Klasy wewnątrz interfejsów............................................................................................312 Sięganie na zewnątrz z klasy wielokrotnie zagnieżdżonej ............................................313

Spis treści 9 Dlaczego klasy wewnętrzne ..................................................................................................314 Domknięcia i wywołania zwrotne...................................................................................316 Klasy wewnętrzne a szkielety sterowania.......................................................................319 Dziedziczenie po klasach wewnętrznych..............................................................................325 Czy klasy wewnętrzne mogą być przesłaniane? ...................................................................326 Lokalne klasy wewnętrzne ........................................... 327 Identyfikatory klas wewnętrznych ........................................................................................329 Podsumowanie.......................................................................................................................329 Rozdział 11. Kolekcje obiektów ................................................................... 331 Kontenery typowane i uogólnione.........................................................................................332 Pojęcia podstawowe ..............................................................................................................335 Dodawanie grup elementów..................................................................................................337 Wypisywanie zawartości kontenerów...................................................................................339 Interfejs List...........................................................................................................................341 Interfejs Iterator.....................................................................................................................345 Interfejs Listlterator ....................................... :............................................................... 348 Klasa LinkedList ...................................................................................................................349 Klasa Stack............................................................................................................................350 Interfejs Set............................................................................................................................352 Interfejs M ap..........................................................................................................................355 Interfejs Queue ......................................................................................................................359 PriorityQueue..................................................................................................................360 Collection kontra Iterator ......................................................................................................362 Iteratory a pętle foreach.........................................................................................................365 Idiom metody-adaptera ...................................................................................................367 Podsumowanie.......................................................................................................................370 Rozdział 12. Obsługa błędów za pomocą wyjątków ...........................................375 Zarys koncepcji ............................... 376 Podstawy obsługi wyjątków..................................................................................................377 Argumenty wyjątków......................................................................................................378 Przechwytywanie wyjątku.....................................................................................................379 Blok try............................................................................................................................379 Obsługa wyjątków...........................................................................................................379 Tworzenie własnych wyjątków.............................................................................................380 Rejestrowanie wyjątków.................................................................................................383 Specyfikacja wyjątków..........................................................................................................386 Przechwytywanie dowolnego wyjątku..................................................................................387 Stos wywołań ..................................................................................................................389 Ponowne wyrzucanie wyjątków......................................................................................389 Sekwencje wyjątków.......................................................................................................392 Standardowe wyjątki Javy.....................................................................................................395 Przypadek specjalny: RuntimeException........................................................................396 Robienie porządków w finally...............................................................................................397 Do czego służy finally.....................................................................................................399 Współdziałanie finally z return.......................................................................................401 Pułapka: zagubiony wyjątek ...........................................................................................402 Ograniczenia wyjątków.........................................................................................................404 Konstruktory..........................................................................................................................407 Dopasowywanie wyjątków....................................................................................................411 Rozwiązania alternatywne.....................................................................................................413 Historia............................................................................................................................414 Perspektywy....................................................................................................................415

10 Thinking in Java. Edycja polska Przekazywanie wyjątków na konsolę..............................................................................418 Zamiana wyjątków sprawdzanych na niesprawdzane.....................................................419 Wskazówki ............................................................................................................................421 Podsumowanie.......................................................................................................................421 Rozdział 13. Ciągi z n a k ó w .............................................................................. 423 Niezmienność ciągów znakowych ........................................................................................423 StringBuilder kontra przeciążony operator *+’ ......................................................................424 Niezamierzona rekursja .........................................................................................................428 Operacje na egzemplarzach klasy String...............................................................................430 Formatowanie wyjścia...........................................................................................................432 Funkcja printt() ...............................................................................................................432 System.out.formatO.........................................................................................................432 Klasa Formatter ...........................................................................................................433 Specyfikatory formatu.....................................................................................................434 Konwersje .......................................................................................................................435 Metoda Slring.format() ...................................................................................................438 Wyrażenia regularne..............................................................................................................439 Podstawy................ ,.................................. 440 Tworzenie wyrażeń regularnych................................................. 442 Kwantyfikatory ...............................................................................................................444 Klasy Pattem oraz Matcher.............................................................................................446 metoda split() ..................................................................................................................453 Operacje zastępowania....................................................................................................454 Metoda reset() .................................................................................................................456 Wyrażenia regularne i operacje wejścia-wyjścia Javy....................................................457 Skanowanie wejścia...............................................................................................................459 Separatory wartości wejściowych ...................................................................................461 Skanowanie wejścia przy użyciu wyrażeń regularnych..................................................462 Klasa StringTokenizer.......................................................................................................... 463 Podsumowanie........................................................... 463 Rozdział 14. Informacje o typach .................................................................................................... 4 65 Potrzeba mechanizmu RTTi..................................................................................................465 Obiekt Class...........................................................................................................................467 Literały Class ..................................................................................................................472 Referencje klas uogólnionych .........................................................................................475 Nowa składnia rzutowania..............................................................................................477 Sprawdzanie przed rzutowaniem...........................................................................................478 Użycie literałów klas.......................................................................................................484 Dynamiczne instanccof...................................................................................................485 Zliczanie rekurencyjne....................................................................................................487 Wytwórnie rejestrowane........................................................................................................488 instanceof a równoważność obiektów Class .........................................................................491 Refleksja — informacja o klasie w czasie wykonania..........................................................493 Ekstraktor metod .............................................................................................................494 Dynamiczne proxy.................................................................................................................497 Obiekty puste.........................................................................................................................501 Imitacje i zalążki .............................................................................................................507 Interfejsy a RTTI ...................................................................................................................507 Podsumowanie.......................................................................................................................512

Spis treści 11 Rozdział 15. Typy ogólne ............................................................................ 515 Porównanie z językiem C++ .................................................................................................516 Proste uogólnienia .................................................................................................................517 Biblioteka krotek.............................................................................................................519 Klasa stosu ......................................................................................................................522 RandomList....................................................... 523 Uogólnianie interfejsów ........................................................................................................524 Uogólnianie metod ................................................................................................................527 Wykorzystywanie dedukcji typu argumentu...................................................................528 Metody uogólnione ze zmiennymi listami argumentów................................................531 Metoda uogólniona w słu żb ie k la sy G en erator .............................................................................. Uniwersalny Generator ............................................ ...................................................... 532 Upraszczanie stosowania krotek .....................................................................................533 Uniwersalny kontener Set ...............................................................................................535 Anonimowe klasy wewnętrzne..............................................................................................538 Budowanie modeli złożonych ...............................................................................................540 Tajemnica zacierania................................................................................. 542 Jak to się robi w C++ ..................................................................................................543 Słowo o zgodności migracji .................................. 546 Kłopotliwość zacierania..................................................................................................547 Na krawędzi ....................................................................................................................548 Kompensacja zacierania........................................................................................................552 Tworzenie egzemplarzy typów .......................................................................................553 Tablice typów ogólnych..................................................................................................556 Ramy......................................................................................................................................560 Symbole wieloznaczne .................................................................................................564 Jak bystry jest kompilator?..............................................................................................567 Kontrawariancja............................. 568 Symbole wieloznaczne bez ram konkretyzacji ..............................................................571 Konwersja z przechwyceniem typu ................................................................................576 Problemy................................................................................................................................578 Typy podstawowe jako parametry typowe .....................................................................578 Implementowanie interfejsów parametryzowanych .......................................................580 Ostrzeżenia przy rzutowaniu...........................................................................................580 Przeciążanie ....... 582 Zawłaszczenie interfejsu w klasie bazowej.....................................................................583 Typy samoskierowanc...........................................................................................................584 Osobliwa rekurencja uogólnienia....................................................................................584 Samoskierowanie ............................................................................................................ 585 Kowariancja argumentów ...............................................................................................588 Dynamiczna kontrola typów..................................................................................................591 Wyjątki ..................................................................................................................................592 Domieszki..............................................................................................................................594 Domieszki w C++ ...........................................................................................................594 Domieszki z użyciem interfejsów...................................................................................595 Zastosowanie wzorca projektowego Decorator ..............................................................596 Domieszki w postaci dynamicznych proxy.....................................................................598 Typowanie utajone ................................................................................................................599 Kompensacja braku typowania utajonego.............................................................................604 Refleksja........................... 604 Aplikowanie metody do sekwencji obiektów .................................................................605 Kiedy nie ma pod ręką odpowiedniego interfejsu...........................................................608 Symulowanie typowania utajonego za pomocą adapterów ............................................610

12 Thinking in Java. Edycja polska Obiekty funkcyjne w roli strategii.........................................................................................613 Podsumowanie — czy rzutowanie jest aż tak złe?................................................................618 Dalsza lektura..................................................................................................................620 Rozdział 16. Tablice ..................................................................................621 Co w nich takiego specjalnego? ............................................................................................621 Tablice to pełnoprawne obiekty ............................................................................................623 Tablice w roli wartości zwracanych......................................................................................625 Tablice wielowymiarowe ......................................................................................................627 Tablice a typy ogólne ...........................................................................................................631 Wytwarzanie danych testowych ............................................................................................633 Metoda Arrays.lill() ........................................................................................................633 Generatory danych ..........................................................................................................634 Tworzenie tablic za pomocą generatorów.......................................................................639 Narzędzia klasy Arrays............................................................................................... 643 Kopiowanie tablic ...........................................................................................................643 Porównywanie tablic.......................................................................................................645 Porównywanie elementów tablic ....................................................................................646 Sortowanie tablic.............................................................................................................649 Przeszukiwanie tablicy posortowanej .............................................................................650 Podsumowanie.......................................................................................................................652 Rozdział 17. Kontenery z bliska ................................................................... 655 Pełna taksonomia kontenerów...............................................................................................655 Wypełnianie kontenerów.......................................................................................................656 Rozwiązanie z generatorem ............................................................................................657 Generatory dla kontenerów asocjacyjnych .....................................................................659 Stosowanie klas abstrakcyjnych......................................................................................662 Interfejs Collection................................................................................................................669 Operacje opcjonalne..............................................................................................................672 Operacje nieobsługiwane ................................................................................................673 Interfejs List...........................................................................................................................675 Kontenery Set a kolejność elementów ..................................................................................678 SortedSet .........................................................................................................................681 Kolejki ...................................................................................................................................683 Kolejki priorytetowe .......................................................................................................684 Kolejki dwukierunkowe..................................................................................................685 Kontenery asocjacyjne...........................................................................................................686 Wydajność.......................................................................................................................688 SortcdMap.......................................................................................................................691 LinkedHasliMap..............................................................................................................692 Haszowanie i kody haszujące................................................................................................693 Zasada działania hashCode()...........................................................................................696 Haszowanie a szybkość...................................................................................................699 Przesłonięcie metody hashCodef)...................................................................................702 Wybór implementacji ............................................................................................................707 Infrastruktura testowa......................................................................................................708 Wybieranie pomiędzy listami ........................................................................................711 Zagrożenia testowania w małej skali ..............................................................................717 Wybieranie pomiędzy zbiorami ......................................................................................719 Wybieranie pomiędzy odwzorowaniami.........................................................................720 Narzędzia dodatkowe ............................................................................................................724 Sortowanie i przeszukiwanie list.....................................................................................727 Niemodyfikowalne kontenery Collection i M ap.............................................................729 Synchronizacja Collection i M ap....................................................................................730

Spis treści 13 Przechowywanie referencji ..................................................................................................731 WeakHashMap............................................................ 734 Kontenery Java 1.0 i 1.1 ........................................................................................................735 Vector i Enumeration......................................................................................................735 Hashtable.........................................................................................................................736 Stack................................................................................................................................736 BitSet...............................................................................................................................738 Podsumowanie.......................................................................................................................740 Rozdział 18. Wejście-wyjście .......................................................................741 Klasa File...................................................... 741 Wypisywanie zawartości katalogu..................................................................................742 Narzędzie do przeglądania katalogów ............................................................................745 Tworzenie katalogów i sprawdzanie ich obecności........................................................750 Wejście i wyjście....................................................................................................................752 Typy InputStream............................................................................................................752 Typy OutputStream.........................................................................................................753 Dodawanie atrybutów i użytecznych interfejsów..................................................................754 Odczyt z InputStream za pomocą FilterlnputStream......................................................755 Zapis do OutputStream za pomocą FilterOutputStream.................................................756 Klasy Reader i Writer............................................................................................................757 Źródła i ujścia danych.....................................................................................................758 Modyfikacja zachowania strumienia...............................................................................758 Klasy niezmienione.........................................................................................................759 Osobna i samodzielna RandomAccessFile............................................................................760 Typowe zastosowania strumieni wejścia-wyjścia.................................................................760 Buforowany plik wejścia.................................................................................................761 Wejście z pamięci ...........................................................................................................762 Formatowane wejście z pamięci .....................................................................................762 Wyjście do pliku .............................................................................................................763 Przechowywanie i odzyskiwanie danych........................................................................765 Odczyt i zapis do plików o dostępie swobodnym...........................................................766 Strumienie-potoki............................................................................................................768 Narzędzia do zapisu i odczytu danych z plików ...................................................................768 Odczyt plików binarnych ...................................... 771 Standardowe wejście-wyjście................................................................................................772 Czytanie ze standardowego wejścia................................................................................772 Zamiana System.out na PrintWriter................................................................................773 Przekierowywanie standardowego wejścia-wyjścia.......................................................773 Sterowanie procesami zewnętrznymi....................................................................................774 Nowe wejście-wyjście...........................................................................................................776 Konwersja danych...........................................................................................................779 Pobieranie podstawowych typów danych.......................................................................782 Widoki buforów ..............................................................................................................783 Manipulowanie danymi przy użyciu buforów ................................................................787 Szczegółowe informacje o buforach...............................................................................787 Pliki odwzorowywane w pamięci ...................................................................................791 Blokowanie plików .........................................................................................................795 Kompresja..............................................................................................................................798 Prosta kompresja do formatu GZIP.................................................................................798 Przechowywanie wielu plików w formacie Z ip..............................................................799 Archiwa Javy (JAR)........................................................................................................801

i a Thinking in Java. Edycja polska Serializacja obiektów............................................................................................................. 803 Odnajdywanie klasy ..............................................................................................................806 Kontrola serializacji ........................................................................................................808 Stosowanie trwałości....................................................................................................... 815 XML ......................................................................................................................................821 Preferencje.............................................................................................................................824 Podsumowanie.......................................................................................................................826 Rozdział 19. Typy wyliczeniowe ................................................................... 827 Podstawowe cechy typów wyliczeniowych ..........................................................................827 Wyliczenia a importy statyczne......................................................................................828 Dodawanie metod do typów wyliczeniowych.......................................................................829 Przesłanianie metod typu wyliczeniowego .....................................................................830 Wyliczenia w instrukcjach wyboru ......................................................................................831 Tajemnica metody values() ...................................................................................................832 Implementuje, nie dziedziczy................................................................................................835 Wybór losowy .......................................................................................................................836 Organizacja na bazie interfejsów...........................................................................................837 EnumSet zamiast znaczników ...............................................................................................841 Stosowanie klasy EnumMap .................................................................................................843 Metody specjalizowane dla elementów wyliczenia ..............................................................844 Typy wyliczeniowe w łańcuchu odpowiedzialności.......................................................848 Typy wyliczeniowe a automaty stanów ..........................................................................851 Rozprowadzanie wielokrotne................................................................................................856 Rozprowadzanie z udziałem typów wyliczeniowych .....................................................859 Stosowanie metod specjalizowanych dla elementów wyliczenia ...................................861 Rozprowadzanie za pomocą EnumMap..........................................................................863 Z tablicą dwuwymiarową................................................................................................864 Podsumowanie.......................................................................................................................865 Rozdział 20. Adnotacje ...............................................................................867 Podstawy składni adnotacji ...................................................................................................868 Definiowanie adnotacji ...................................................................................................869 Metaadnotacje .................................................................................................................870 Procesory adnotacji ...............................................................................................................871 Elementy adnotacji..........................................................................................................872 Ograniczenia wartości domyślnych ................................................................................872 Generowanie plików zewnętrznych................................................................................873 Adnotacje nie dają się dziedziczyć .................................................................................876 Implementowanie procesora ...........................................................................................876 Przetwarzanie adnotacji za pomocą apt.................................................................................879 Program apt a wizytacje ........................................................................................................883 Adnotacje w testowaniujednostkowym................................................................................886 @Unit a typy ogólne .......................................................................................................895 Implementacja @Unil .....................................................................................................896 Usuwanie kodu testującego.............................................................................................903 Podsumowanie.......................................................................................................................905 Rozdział 21. Współbieźność ........................................................................ 907 Oblicza wspólbieżności.........................................................................................................908 Szybsze wykonanie .........................................................................................................909 Ulepszanie projektu.........................................................................................................911 Podstawy wielowątkowości...................................................................................................912 Definiowanie zadań.........................................................................................................913 Klasa Thread ...................................................................................................................914 Wykonawcy.....................................................................................................................916

Spis treści 15 Zwracanie wartości z zadań ............................................................................................919 Usypianie — wstrzymywanie wątku ..............................................................................920 Priorytet wątku.............................................................,................................................. 921 Przełączanie.................................................................................,.................................. 923 Wątki-demony............................................................... 924 Wariacje na temat wątków..............................................................................................928 Terminologia...................................................................................................................933 Łączenie wątków................................ 934 Tworzenie reaktywnego interfejsu użytkownika............................................................935 Grupy wątków.................................................................................................................. Przechwytywanie wyjątków.......................................................................................... Współdzielenie zasobów .......................................................................................................940 Niewłaściwy dostęp do zasobów ....................................................................................940 Rozstrzyganie współzawodnictwa o zasoby współdzielone...........................................943 Atomowość i widoczność ...............................................................................................948 Klasy „atomowe” ............................................................................................................955 Sekcje krytyczne..............................................................................................................956 Synchronizacja dostępu na bazie innych obiektów.........................................................961 Lokalna pamięć wątku ....................................................................................................962 Przerywanie wykonania zadań ..............................................................................................964 Ogród botaniczny (symulacja)........................................................................................964 Przerywanie zablokowanego wątku................................................................................967 Wymuszanie przerwania wykonania...............................................................................968 Sprawdzanie przerwania .................................................................................................976 Współdziałanie wątków.........................................................................................................978 Metody wait() i notiiyAll() .............................................................................................979 notify)) kontra notifyAlł() ...............................................................................................984 Producenci i konsumenci ................................................................................................987 Producenci, konsumenci i kolejki ...................................................................................992 Przekazywanie danych pomiędzy zadaniami za pomocą potoków.................................997 Zakleszczenie ....................................................................... 999 Nowe komponenty biblioteczne.......................................................................................... 1004 CountDownLatch .......................................................................................................... 1004 CyclicBarrier................................................................................................................. 1006 DelayQueue....................................................................... 1008 PriorityBlockingQueue ................................................................................................. 1011 Sterowanie szklarnią— planowanie uruchamiania zadań............................................ 1014 Semaphore..................................................................................................................... 1017 Exchanger...................................................................................................................... 1020 Symulacje ............................................................................................................................ 1022 Symulacja okienka kasowego ....................................................................................... 1022 Symulacja sali restauracyjnej........................................................................................ 1027 Rozdzielanie zadań.......................................................................................................1031 Wydajność ........................................................................................................................... 1036 Porównanie technologii muteksów ..............................................................................1036 Kontenery bez blokad ..................................................................................................1044 Blokowanie optymistyczne..........................................................................................1051 Blokady RcadWriteLock............................................................................................... 1053 Obiekty aktywne.................................................................................................................. 1055 Podsumowanie...................................................................................................................1059 Dalsza lektura................ 1061

16 Thinking in Java. Edycja polska Rozdział 22. Graficzne interfejsy użytkownika................................................ 1063 Aplety.................................................................................................................................. 1065 Podstawy biblioteki Swing.................................................................................................. 1066 Platforma prezentacyjna................................................................................................ 1069 Tworzenie przycisku ..........................................................................................................1069 Przechwytywanie zdarzenia ................................................................................................ 1070 Obszary tekstowe................................................................................................................. 1073 Rozmieszczanie elementów interfejsu ................................................................................ 1074 BorderLayout ................................................................................................................ 1075 FlowLayoul................................................................................................................... 1076 GridLayout.................................................................................................................... 1076 GridBagLayout.............................................................................................................. 1077 Pozycjonowanie bezpośrednie ...................................................................................... 1077 BoxLayout..................................................................................................................... 1077 Najlepsze rozwiązanie?................................................................................................. 1078 Model zdarzeń w Swingu.................................................................................................... 1078 Rodzaje zdarzeń i odbiorników..................................................................................... 1079 Śledzenie wielu zdarzeń ...............................................................................................1084 Wybrane komponenty Swing .............................................................................................. 1086 Przyciski ........................................................................................................................ 1087 Ikony ............................................................................................................................. 1089 Podpowiedzi.................................................................................................................. 1091 Pola tekstowe ................................................................................................................ 1091 Ramki ............................................................................................................................ 1093 Miniedytor..................................................................................................................... 1094 Pola wyboru .................................................................................................................. 1095 Przyciski wyboru........................................................................................................... 1096 Listy rozwijane.............................................................................................................. 1097 Listy............................................................................................................................... 1098 Zakładki......................................................................................................................... 1100 Okna komunikatów....................................................................................................... 1100 Menu ............................................................................................................................1102 Menu kontekstowe .......................................................................................................1107 Rysowanie..................................................................................................................... 1109 Okna dialogowe ............................................................................................................ 1112 Okna dialogowe plików ................................................................................................ 1115 HTML w komponentach Swing.................................................................................... 1117 Suwaki i wskaźniki postępu................................................................ 1117 Zmiana stylu interfejsu.................................................................................................. 1119 Drzewka, tabele i schowek............................................................................................ 1121 JNLP oraz Java Web Start................................................................................................... 1121 Swing a współbieżność........................................................................................................ 1126 Zadania długotrwałe...................................................................................................... 1126 Wizualizacja wielowątkowości interfejsu użytkownika..............................................1133 Programowanie wizualne i komponenty JavaBean............................................................1135 Czymjest komponent JavaBean?.................................................................................. 1136 Wydobycie informacji o komponencie poprzez klasę Introspcctor.............................1138 Rardziej wyszukany komponent ..................................................................................1143 Komponenty JavaBean i synchronizacja .....................................................................1146 Pakowanie komponentu JavaBean................................................................................ 1150 Bardziej złożona obsługa komponentów JavaBean .......................................................1151 Więcej o komponentach JavaBean.................................................................................1152 Alternatywy wobec biblioteki Swing.................................................................................. 1152

Spis treści 17 Flex — aplikacje klienckie w formacie Flash....................................................................1153 Ahoj, Flex...................................................................................................................... 1154 Kompilowanie MXML.................................................................................................. 1155 MXML i skrypty ActionScript...................................................................................... 1156 Kontenery i kontrolki ...................................................................................................1156 Efekty i style ................................................................................................................1158 Zdarzenia....................................................................................................................... 1159 Połączenie z Javą........................................................................................................... 1159 Modele danych i wiązanie danych...............................................................................1162 Kompilowanie i instalacja............................................................................................. 1163 Aplikacje SWT ........................................................... nv-t Instalowanie SW T......................................................................................................... 1165 Ahoj, SWT .................................................................................................................... 1165 Eliminowanie powtarzającego się kodu.......................................................................1168 Menu ............................................................................................................................1170 Panele zakładek, przyciski i zdarzenia.......................................................................... 1171 Grafika........................................................................................................................... 1174 Współbieżność w SW T................................................................................................. 1176 SWT czy Swing? ....................................................................................................... 1178 Podsumowanie..................................................................................................................... 1178 Zasoby........................................................................................................................... 1179 Dodatek A Materiały uzupełniające........................................................... 1181 Suplementy do pobrania...................................................................................................... 1181 Thinking in C ....................................................................................................................... 1181 Szkolenie Thinking in Java ................................................................................................1182 Szkolenie na CD-ROM-ie Hands-On Java.........................................................................1182 Szkolenie Thinking in Objects............................................................................................... 1182 Thinking in Enterprise Java................................................................................................. 1183 Thinking in Patterns (with Java).......................................................................................... 1184 Szkolenie Thinking in Patterns............................................................................................ 1184 Konsultacja i analiza projektów .........................................................................................1185 Dodatek B Zasoby ................................................................................ 1187 Oprogramowanie................................................................................................................. 1187 Edytory i środowiska programistyczne..............................................................................1187 Książki................................................................................................................................. 1188 Analiza i projektowanie ...............................................................................................1189 Python ..........................................................................................................................1191 Lista moich książek....................................................................................................... 1191 Skorowidz ............................................................................1193 BIBLIOTEKA PŁ

Przedmowa Początkowo Java była dla mnie „kolejnym językiem programowania ”— jakim oczywi­ ście pod wieloma względamijest. Z biegiem czasu, oraz po głębszym poznaniu, zacząłem dostrzegać, iż podstawowe za­ mierzenie tego języka jest inne niż wszystkich, z którymi do tej pory się spotkałem. Programowanie to radzenie sobie ze złożonością: złożoność problemu, który chcemy rozwiązać, potęguje złożoność maszyny, na której pracujemy. Właśnie z uwagi na złożoność większość projektów kończy się niepowodzeniem. Żaden z języków programowania, które poznałem, nie rozwinął się na tyle, aby głównym jego celem było przezwyciężanie złożoności samego programowania i późniejszej konserwacji gotowych programów1. Oczywiście wiele decyzji podczas projektowania języków zostało podjętych z myślą o ułatwieniach, ale okazywało się, iż zawsze istniały kwestie, które były uważane za niezbędne, i należy je dołączyć. Nieuchronnie te właśnie dodatki powodują, że progra­ miści „przeginają”, stosując taki język. Na przykład C++ musiał być zgodny wstecz z C (aby pozwolić programistom C na łatwą migrację) i do tego równie wydajny. Oba cele są bardzo ważne i znacznie przyczyniły się do sukcesu C++, lecz ujawniły również do­ datkowe komplikacje, które uniemożliwiły ukończenie niektórych projektów (naturalnie można obwiniać programistów i menedżerów, ale jeżeli język może pomóc, wyłapując błędy, to dlaczego tego nie robi?). Kolejny przykład: Visual Basic (VB) był powiązany z BASIC-em, który nie został zaprojektowany jako rozszerzalny, stąd wszystkie dodatki nagromadzone w VB spowodowały powstanie naprawdę okropnej i niemożliwej do utrzymania składni. Perl jest zgodny wstecz z takimi narzędziami znanymi z systemu UNIX jak Awk, Sed, Grep i innymi, które miał zastąpić, a w rezultacie często jest oskarżany o generowanie „kodu tylko do zapisu” (co znaczy, że po kilku miesiącach nie można go zrozumieć). Z drugiej strony w C++, VB, Perlu i innych językach programowania, jak np. Smalltalk, projektanci skupili część wysiłku na kwestiach złożoności; w efekcie wszyst­ kie te języki są skutecznie stosowane w odpowiednich dla nich dziedzinach. To, co wywarło na mnie największe wrażenie, kiedy poznawałem Javę, to fakt, że wśród innych celów projektantów z firmy Sun znalazła się także redukcja złożoności dla pro­ gramisty. To tak, jakby powiedzieć: „Nie dbamy o nic poza zmniejszeniem czasu i trudności tworzenia porządnego kodu”. W początkowej fazie dążenie to kończyło się otrzymaniem 1 Najbliżej tego celujest według mnie Python — zobacz www.Python.org.

20 Thinking in Java. Edycja polska kodu, który niestety nie działał zbyt szybko (chociaż w przeszłości było wiele obietnic dotyczących zwiększenia szybkości działania programów), lecz zmniejszenie czasu pra­ cy programisty było zdumiewające — potrzebował on teraz połowy lub nawet mniej czasu niż na napisanie równoważnego programu w C++. Przyczynia się to do dużych oszczędności, ale to nie wszystkie zalety Javy. Java idzie dalej, upraszczając wszystkie skomplikowane zadania, jak wiclowątkowość i programowanie sieciowe, cechy języka lub biblioteki. Rozwiązuje także kilka naprawdę bardzo skomplikowanych problemów dotyczących programów działających na dowolnej platformie sprzętowej, dynamicznej zmiany kodu czy nawet bezpieczeństwa, które, na skali złożoności, można umieścić gdzieś pomiędzy „utrudnieniem” a „problemem nie do rozwiązania”. Zatem pomimo pro­ blemów z wydajnością widać, iż możliwości Javy są olbrzymie, przez co może ona uczy­ nić z nas znacznie wydajniejszych programistów. Pod każdym względem — tworzenie oprogramowania, praca grupowa w celu tworzenia oprogramowania, budowa interfejsu użytkownika w celu komunikacji między progra­ mem a użytkownikiem, uruchamianie programów na różnych rodzajach maszyn i łatwe pisanie programów, które komunikują się poprzez Internet — Java zwiększa możliwości komunikacyjne między ludźmi. Uważam, że wyniku rewolucji komunikacyjnej nie należy postrzegać jedynie przez pry­ zmat możliwości przesyłania ogromnych ilości bitów; dostrzeżmy prawdziwą rewolucję objawiającą się nowymi możliwościami porozumiewania się — indywidualnie, w gru­ pach, ale również jako cała ludzkość. Chodzą słuchy, że następna rewolucja będzie po­ legała na powstaniu czegoś w rodzaju globalnego umysłu, tworzonego przez pewną grupę osób i odpowiednią liczbę połączeń między nimi. Java może — lub też nie — stać się narzędziem wspomagającym tę rewolucję. Już sama ta możliwość powoduje, że czuję, jakbym robił coś znaczącego, podejmując próbę nauczenia tego języka. Java SE5 i SE6 Niniejsze wydanie książki czerpie całymi garściami z ulepszeń wprowadzonych do języka Java w jego wersji oznaczonej przez firmę Sun jako JDK 1.5, a potem przemianowanej na JDK.5 albo J2SE5; wreszcie nazwa została ustalona jako Java SE5. Zmiany wprowa­ dzone do Javy SE5 w znacznej mierze polegały na próbie jeszcze większego zbliżenia języka do programisty. Postaram się wykazać, że choć sukces nie jest całkowity, to faktycz­ nie zmiany stanowią wielki krok we właściwym kierunku. Jednym z celów tej edycji jest ujęcie ulepszeń Javy SE5 i SE6, ich przedstawienie i wkom­ ponowanie w pierwotną treść książki. Oznacza to, że niniejsze wydanie jest ściśle ukie­ runkowane na specyfikę SE5 i SE6 i większości kodu dołączonego do książki nie da się skompilować za pomocą starszych wersji Javy; kompilator zgłosi błąd i zaniecha kom­ pilacji. Myślę jednak, że korzyści płynące z udogodnień nowych wydań języka są warte tak radykalnej decyzji. Tych, którzy w jakiś sposób są związani z poprzednimi wersjami Javy, odsyłam do po­ przednich edycji niniejszej książki, udostępnionych w formie elektronicznej w witrynie www.MindView.net. Z różnych względów bieżące wydanie książki nie jest udostępniane w takiej formie — ze wskazanej witryny można za to pobrać wydania poprzednie.

Przedmowa 21 Java SE6 Niniejsza książka to monumentalny, niezwykle czasochłonny projekt; w toku redakcji, zanim doszło do publikacji, pojawiła się wersja beta Javy SE6 (nazwa kodowa: mu­ stang). Choć w Javie SE6 pojawiło się kilka pomniejszych zmian, które ulepszyłyby niektóre z przykładów prezentowanych w książce, zasadniczo pojawienie się wydania SE6 nie wpływa w znaczącym stopniu na aktualną jej treść; zmiany ograniczają się bo­ wiem do usprawnień w bibliotekach i optymalizacji, a więc aspektów spoza głównego nurtu wykładu zawartego w książce. Kod dołączony do wydawnictwa został pomyślnie przetestowany z próbnymi wersjami kompilatora Java SE6, nie spodziewam się więc zmian wpływających istotnie na treść książki. Gdyby takie zmiany pojawiły się w finalnej wersji Javy SE6, zostaną uwzględ­ nione w kodzie źródłowym dołączonym do publikacji, który można pobrać ze strony www.MindView.net. Okładka książki sugeruje, że jej terść dotyczy wydań SE5 i SE6, co należy rozumieć: „napisana pod kątem Javy SE5 z uwzględnieniem znaczących zmian języka wprowa­ dzanych przez tę wersję, ale stosująca się również do przyszłej wersji SE6”. Przedmowa do wydania czwartego Nowa edycja książki to satysfakcja z możliwości jej poprawienia, na bazie doświadczeń zdobytych od czasu publikacji poprzedniego wydania. Owe doświadczenia niejednokrotnie potwierdzają powiedzenie: „doświadczenie to coś, zyskiwanego przy porażce”. Mam więc okazję do poprawienia tego, co dla Czytelników okazało się kłopotliwe albo żmudne. Jak zwykle, przygotowania do następnego wydania inspirują nowymi pomysłami, a trud aktu­ alizacji jest z nawiązką rekompensowany wciąż intensywnym smakiem odkrycia i możli­ wością wyrażenia swoich pomysłów lepiej niż poprzednio. Gdzieś tam kołacze się też świadomość, że trzeba to wydanie zrobić tak dobrze, żeby skło­ nić do jego zakupu posiadaczy wydań poprzednich. To silna presja do zwiększenia jakości, przepisania i reorganizacji wszystkiego, co tego wymaga — wszystko po to, by kolejne wydanie książki było nowym i wartościowym doświadczeniem dla tych, do których tę książkę kieruję. Zmiany Do poprzednich wydań książki dołączana była płyta CD-ROM; tym razem zrezygnowałem z niej. Zasadnicza treść owej płyty, w postaci multimedialnego seminarium Thinking in C (utworzonego dla MindView przez Chucka Allisona) jest teraz dostępna w postaci prezen­ tacji Flash do pobrania z witryny MindView. Celem tamtego seminarium było przygoto­ wanie Czytelników nieznających dostatecznie składni języka C do przyswojenia materiału prezentowanego w książce. Choć w dwóch rozdziałach zawarte jest szczegółowe omówie­ nie składni języka, może być ono niewystarczające dla tych osób, które nie miały wcześniej styczności z C; Thinking in Cjest właśnie dla nich — ma im pomóc osiągnąć odpowiedni poziom przygotowania do lektury.

22 Thinking in Java. Edycja polska Rozdział „Współbieżność” (który we wcześniejszych wydaniach nosił tytuł „Wielowątko- wość”) został przepisany z uwzględnieniem zmian wprowadzonych do bibliotek imple­ mentacji współbieżności w Javie SE5; wciąż zawiera jednak podstawowe wiadomości do­ tyczące pojęć związanych ze stosowaniem wątków. Bez tych podstaw zrozumienie bardziej zaawansowanych zagadnień wielowątkowości byłoby niezmiernie trudne. Spę­ dziłem nad tym rozdziałem wiele miesięcy, nurzając się w krainie współbieżności; ostatecznie prezentuje on nie tylko podstawy, ale i wkracza na terytoria rezerwowane dla bardziej zaawansowanych. Każde znaczące rozszerzenie języka, obecne w Javie SE5, jest omawiane w osobnym, nowym rozdziale książki. Omówienie zmian pomniejszych zostało włączone wprost do istniejącej bazy materiału. Z racji mojego osobistego zainteresowania wzorcami pro­ jektowymi w książce pojawiło się ich nieco więcej niż poprzednio. Zasadniczej reorganizacji uległ układ materiału. Wynikła ona z obserwacji procesu na­ uczania oraz z pewnej zmiany mojego własnego postrzegania znaczenia słowa „roz­ dział”. Poprzednio wydawało mi się, że rozdział konstytuuje materiał o dostatecznie du­ żej objętości, ale nauczając wzorców projektowych, przekonałem się, że słuchacze radzą sobie z materiałem najlepiej, kiedy zaraz po przedstawieniu wzorca przechodzimy do ćwiczeń z jego użyciem — efekt jest znakomity nawet wówczas, jeśli oznacza przerwa­ nie ciągłości wywodu (przekonałem się przy okazji, że i mnie — jako wykładowcy — bardziej odpowiada taki rytm wykładu). W tym wydaniu starałem się więc łamać roz­ działy wedle zagadnień, nie martwiąc się pozornym „niedomiarem” materiału w niektó­ rych spośród nich. Sądzę, że to postęp. Zdałem sobie także sprawę ze znaczenia testowania kodu. Bez wbudowanego systemu testującego zawierającego testy uruchamiane podczas każdego budowania systemu nie można mieć pewności, czy tworzony kod jest niezawodny. Aby ją uzyskać, na potrzeby niniejszej książki została stworzony specjalna infrastruktura testowania prezentująca i sprawdzająca poprawność wyników generowanych przez każdy program (dzieło to powstało w języku Python, a można je znaleźć w archiwum kodu źródłowego tej książki do­ stępnym w witrynie www.MindView.net). Testowanie jako takie zostało omówione w specjalnym dodatku, publikowanym pod adresem http://MindView.net/Books/BetterJava, przedstawiającym wszystkie zagadnienia traktowane aktualnie przeze mnie jako podsta­ wowe umiejętności każdego programisty używającego Javy. Poza tym przeanalizowałem każdy przykład przedstawiony w niniejszej książce, zada­ jąc sobie pytanie: „Dlaczego zrobiłem to właśnie w taki sposób?”. W większości przy­ padków wprowadziłem pewne modyfikacje i poprawki, zarówno po to, by przykłady stały się bardziej spójne, jak również w celu przedstawienia najlepszych, w moim mniemaniu, praktyk programowania w Javic (oczywiście w ramach ograniczeń, jakie narzuca książka stanowiąca wprowadzenie do języka). Sporo istniejących przykładów zostało w znaczą­ cym stopniu przeprojektowanych i zmodyfikowanych. Usunąłem także przykłady, które według mnie nic miały już sensu; dodałem też zupełnie nowe programy. Czytelnicy nadesłali wiele wspaniałych komentarzy na temat trzech pierwszych wydań książki, co oczywiście było dla mnie niezwykle przyjemne. Niemniej jednak zawsze może się zdarzyć, że od czasu do czasu ktoś prześle uwagi krytyczne. Z jakiegoś powodu systematycznie pojawiały się uwagi, że: „Książka jest zbyt gruba”. Osobiście sądzę, że jeśli jedynym zarzutem jest „zbyt duża liczba stron”, nie jest to zbyt poważna krytyka

Przedmowa 23 książki (znana jest uwaga cesarza Austrii dotycząca prac Mozarta, którym zarzucił „zbyt wiele nut!”; nie porównuję się bynajmniej z Mozartem). Poza tym mogę tylko za­ kładać, że uwagę taką nadesłała osoba nieświadoma ogromu języka Java, która jedno­ cześnie nie widziała innych książek na ten temat. Niemniej jednak przygotowując ni­ niejszą książkę, starałem się skrócić fragmenty zdezaktualizowane albo przynajmniej tc, które nie mają kluczowego znaczenia. Ogólnie rzecz biorąc, starałem się wszystko przejrzeć, usunąć z tekstu tego wydania książki wszystkie niepotrzebne informacje, wprowadzić modyfikacje i poprawić wszystko, co tylko mogłem. Nie miałem żadnych oporów przed usuwaniem fragmentów tekstu, gdyż oryginalne materiały wciąż są na mojej witrynie WWW (www.MindView.org) jako ogólnie dostępne pierwsze, drugie i trze­ cie wydanie książki oraz dodatki. Tych, którym ciągle przeszkadza objętość książki, najmocniej przepraszam. Możecie wierzyć bądź nie, bardzo się starałem, aby była mniejsza. Projekt okładki Okładka Thinking in Java jest inspirowana zaznaczającym się w zdobnictwie i archi­ tekturze nurtem rzemiosła artystycznego Arts & Crafts, mającym swój początek na przełomie zeszłych wieków, z apogeum w pierwszym dwudziestoleciu ubiegłego wieku. Nurt ten powstał w Anglii jako reakcja na produkcję taśmową i ogólnie Rewolucję Przemysłową z jednej strony oraz wysoce ozdobny styl wiktoriański z drugiej. Arts & Crafts to oszczędność formy, rękodzieło i szacunek dla indywidualnego wkładu rze­ mieślnika, co nie oznacza jednak rezygnacji ze stosowania nowoczesnych narzędzi. Dziś mamy do czynienia z echami tamtego nurtu: na przełomie wieków obserwujemy ewolucję od surowych początków rewolucji komputerowej (przesyłania bitów) w kie­ runku czegoś bardziej znaczącego, subtelniejszego; również dziś można mówić o rze­ miośle programowania, które jest czymś więcej niż tylko produkowaniem kodu. Tak samo postrzegam język Java: to próba wyniesienia programisty ponad surową me­ chanikę systemu operacyjnego z podniesieniem jego pracy do rangi rzemiosła nie tylko czysto użytkowego. Zarówno autor tej książki, jak i projektant okładki (przyjaciele od dziecka) znaleźli w owym nurcie inspirację; obaj posiadają meble, lampy i inne elementy zdobnictwa i architektury wnętrz, które albo pochodzą wprost z tamtego okresu, albo są na jego dziełach wzorowane. Inny motyw okładki kojarzy się z rodzajem gabloty, w której entomolodzy i zwykli zbieracze owadów mogliby prezentować okazy swojej kolekcji. Owe owady są obiek­ tami, umieszczonymi w obiekcie gabloty. Sam obiekt gabloty został osadzony w obiekcie okładki; tak można zilustrować podstawową koncepcję agregacji w programowaniu obiektowym. Oczywiście programista skojarzy sobie zawartość gabloty z dręczącymi go „pluskwami”; na okładce widać owe „pluskwy”: wyłapane, zidentyfikowane i (niestety) uśmiercone; można to odnieść do możliwości języka Java w zakresie wyszukiwania, pre­ zentowania i eliminowania błędów (co zaliczam do silniejszych atrybutów tego języka). Dla potrzeb niniejszego wydania przygotowałem akwarelę wykorzystaną jako tło dla okładki.

24 Thinking in Java. Edycja polska Podziękowania W pierwszej kolejności chciałbym podziękować moim wspólnikom, którzy pracują ze mną, prowadząc kursy, konsultacje i tworząc projekty nauczania. Są to: Dave Barlett, Bill Venners, Chuck Allison, Jeremy Meyer i Jamie King. Jestem wdzięczny za Waszą cierpliwość w czasie, gdy usiłowałem opracować najlepszy model współpracy dla nie­ zależnych gości, takich jak my. Ostatnio, niewątpliwie za przyczyną Internetu, jestem kojarzony ze zdumiewająco liczną grupą osób, które wspomagają mnie w moich wysiłkach, zazwyczaj pracując w swych własnych domowych biurach. Swego czasu musiałbym całkiem sporo zapłacić za wynaję­ cie pomieszczeń biurowych zdolnych pomieścić wszystkie te osoby, jednak obecnie, dzięki Internetowi, poczcie i rozmowom telefonicznym, mogę korzystać z ich pomocy bez zbęd­ nych kosztów. Wszyscy okazaliście się niezwykle przydatni w moich próbach „popra­ wienia kontaktów z innymi” i mam nadzieję, że wciąż będę mógł poprawiać swoją pracę, korzystając z wysiłków innych osób. Paula Steuer okazała się nieoceniona, jeśli chodzi o kontrolę moich dorywczych praktyk biznesowych i sprawienie, że nabrały one nieco sensu (dziękuję Ci, Paulo, za popędzanie mnie, gdy nie chce mi się czegoś robić). Jaśnie wielmożny pan Jonathan Wilcox poddał dokładnym badaniom strukturę mojej firmy, sprawdził każde potencjalne niebezpieczeństwo i przepchnął nas przez proces legaliza­ cji naszych poczynań. Dziękuję za troskę i wytrwałość. Sharlynn Cobaugh (która odkryła Paulę) stała się ekspertem w dziedzinie przetwarzania dźwięku i w ogromnym stopniu przyczyniła się od powstania multimedialnych materiałów szkoleniowych oraz rozwiązania wielu innych problemów. Dziękuję Ci za wytrwałość w obliczu trudnych problemów komputerowych. Pracownicy firmy Amaio z Pragi pomogli mi w realizacji kilku pro­ jektów. Początkowym inspiratorem pracy przez Internet był Daniel Will-Harris i to dzięki niemu powstały wszystkie moje projekty graficzne. Moim nieoficjalnym mentorem stał się na przestrzeni lat Gerald Weinberg, a to za sprawą jego konferencji i warsztatów, za które mu dziękuję. Przy korekcie technicznej czwartego wydania nieoceniony okazał się Ervin Varga — choć nad jakością rozdziałów i przykładów pracowało również wielu innych. Ervin był głównym recenzentem technicznym książki, podjął się też. zadania przepisania przewod­ nika po rozwiązaniach pod kątem nowego wydania. Znalazł trochę błędów i wprowadził szereg ulepszeń, które świetnie uzupełniały pierwotny tekst. Jego wnikliwość i pieczołowi­ tość jest dla mnie fenomenem — to najlepszy korektor, jakiego znałem. Dziękuję, Ervin. Kiedy trzeba było zastanowić się nad nowymi pomysłami, korzystałem ze swojego błoga prowadzonego w ramach witryny www.Artima.com pozostającej pod opieką Billa Ven- nersa. Czytelnicy tego forum, przesyłający swoje komentarze i uwagi, pomogli mi skry­ stalizować koncepcje. Korzystałem ze wskazówek Jamesa Watsona, Howarda Lovatta, Michaela Barkcra i innych; szczególnie dziękuję tym, którzy pomogli mi w kwestii ty­ pów ogólnych. Markowi Welshowi dziękuję za ciągłą pomoc i wsparcie.

Przedmowa 25 Niezwykle pomocny okazał się ponownie Evan Cofsky, który arkana konfiguracji i opieki nad linuksowymi serwerami WWW wyssał najwyraźniej z mlekiem matki, dzięki cze­ mu serwer witryny MindView jest wciąż dostępny i bezpieczny. Specjalne podziękowania kieruję do mojej nowej przyjaciółki — chodzi o kawę, która podtrzymywała entuzjazm do projektu. Muszę przyznać, że Camp4 Coffee w Crested Buttle (w Kolorado) — gdzie zwykli przesiadywać słuchacze kursów MindView w cza­ sie przerw — serwuje najlepszy na świecie wikt. Dziękuję Alowi Smithowi za powoła­ nie tej placówki do życia i tchnięcie w nią tego świetnego ducha, który stanowi dziś nieodłączną część atmosfery Crested Buttle. Pozdrowieniu dla wszystkich bywalców Camp4, ochoczo żłopiących tamtejsze napoje. Dziękuję całej załodze wydawnictwa Prentice Hall; nieodmiennie otrzymuję od nich wszystko, czego potrzebuję, a bywam wybredny. Redaktorzy i redaktorki dokładająjednak starań, aby współpraca przebiegała bez zgrzytów. Proces twórczy ujawnił nieocenioną przydatność niektórych narzędzi; za każdym ra­ zem, gdy z nich korzystam, jestem niezwykle wdzięczny ich twórcom. Biblioteka Cy- gwin (http://www.cygwin.com) rozwiązała niezliczone problemy, z którymi system Win­ dows nie mógł (lub nie chciał) sobie poradzić; z każdym dniem stawałem się coraz bardziej przywiązany do niej (gdybym tylko ją miał 15 lat temu, kiedy mój mózg był ściśle związany z edytorem Gnu Emacs). IBM Eclipse (http://www.eclipse.org) jest na­ prawdę cudownym darem dla społeczności programistów, a ponieważ wciąż jest roz­ wijany, sądzę, że jeszcze dużo dobrego z niego wyniknie (od kiedy to IBM jest na fali? musiałem coś przegapić). Nowe ścieżki w narzędziach programistycznych pracowicie wytycza JetBrains IntelliJ Idea — również wiele na tym skorzystałem. Przy pracach nad tą książką zacząłem korzystać z oprogramowania Enterprise Architect firmy Sparxsystcms; szybko się okazało, że to mój ulubiony edytor języka UML. W wielu sytuacjach korzystałem z Jalopy — narzędzia formatującego kod autorstwa Marco Hunsickera (www.triemax.com)-, sam Marco pomógł mi skonfigurować program do moich specyficznych potrzeb. Od czasu do czasu korzystałem też z edytora programistycznego (i rozmaitych wtyczek do niego) JEdit Slavy Pestova — to zresztą świetny edytor dla słuchaczy moich seminariów. I oczywiście, co powtarzam wystarczająco często i przy każdej sposobności, bezustannie rozwiązuję problemy, posługując się językiem Python (www.Pvthon.org), wymyślonym przez mego znajomego Guido Van Rossuma oraz zabawnych geniuszy z PythonLabs z którymi spędziłem kilka wspaniałych dni wypełnionych programistycznym sprintem (Tim, oprawiłem w ramki pożyczoną od Ciebie mysz i oficjalnie nazwałem ją „TimMouse”). Ludzie, musicie jadać lunche w zdrowszym miejscu (dziękuję także całej społeczności osób używających Pythona, zdumiewającej grupie osób). Mnóstwo osób przesyła mi poprawki i jestem im wdzięczny, ale w szczególności podzię­ kowania niech przyjmą (za pierwsze wydanie): Kevin Raulerson (odnalazł tony błędów), Bob Resendes (po prostu niewiarygodny), John Pinto, Joe Dante, Joe Sharp (wszyscy trzej byli fantastyczni), David Combs (wiele gramatycznych i wyjaśniających poprawek), dr Robert Stephenson, John Cook, Franklin Chen, Zev Griner, David Karr, Leander A. Stroschein, Steve Clark, Charles A. Lee, Austin Maher, Dennis P. Roth, Roque Oliveira, Douglas Dunn, Dejan Ristic, Neil Galamcau, David B. Malkovsky, Steve Wilkinson

26 Thinking in Java. Edycja polska oraz całe rzesze innych osób. Prof. Marc Meurrens dołożył mnóstwo starań, by opubliko­ wać i udostępnić elektroniczną wersję pierwszej edycji książki w Europie. Dziękuję wszystkim, którzy pomogli mi przepisać przykłady pod kątem biblioteki Swing (w drugim wydaniu książki) oraz pomagali mi w inny sposób. Są nimi: Jon Shvarts, Thomas Kirsch, Rahim Adatia, Rajesh Jain, Ravi Manthena, Banu Rajamani, Jens Brandt, Nitin Sliivaram, Malcolm Davis oraz wszyscy ci, którzy udzielili mi pomocy. W czwartym wydaniu korzystałem z uprzejmości Chrisa Grindstaffa, który pomagał mi w opracowaniu części poświęconej bibliotece SWT. Z kolei Sean Neville napisał pierwszą wersję części poświęconej Flex. Spotkałem w swoim życiu mnóstwo uzdolnionych technicznie ludzi, którzy stali się moimi przyjaciółmi, a także wyróżniali się tym, że uprawiali jogę oraz praktykowali inne formy poprawy duchowej, według mnie, inspirujące i kształcące. Są to: Kraig Brocks- chmidt i Gen Kiyooka. Nie jest dla mnie zaskoczeniem to, iż zrozumienie Delphi pomogło mi pojąć Javę, po­ nieważ wiele pojęć i założeń projektowych tych języków jest wspólnych. Moi przyja­ ciele od Delphi wsparli mnie w zgłębianiu tego cudownego środowiska programowania. Należą do nich: Marco Cantu (kolejny Włoch — czyżby przesiąknięcie łaciną dawało przepustkę do programowania?), Neil Rubenking (przed poznaniem komputerów był wegetarianinem, praktykował jogę i Zen) oraz oczywiście Zack Urlocker, stary kumpel, z którym podróżowałem po świecie. Wszyscy jesteśmy zaś dłużnikami Andersa Hejlsberga, który wciąż trudzi się z C# (który to język, jak się będzie można przekonać z książki, stanowił silne źródło inspiracji dla Javy SE5). Spostrzeżenia i wsparcie mojego przyjaciela Richarda Hale’a Shawa (Kima również) były bardzo pomocne. Z Richardem spędziliśmy wiele miesięcy, prowadząc wspólnie se­ minaria i próbując opracować doskonałe przykłady dla uczestników. Projekt książki, okładki i zdjęcie na okładce zostały wykonane przez mojego przyjaciela Daniela Will-Harrisa, znanego autora i projektanta (www.Will-Harris.com), który bawił się w szkole średniej stemplami czcionek, oczekując niecierpliwie na wynalezienie komputerów i możliwość składu komputerowego. Jednak to ja stworzyłem gotowe do składu strony, toteż błędy składu oryginalnego wydania książki są moje. Pisząc książkę, używałem Microsoft* Word XP dla Windows, a do stworzenia gotowych stron programu Adobe Acrobat; książka została wydrukowana bezpośrednio z plików PDF. W czasie powstawania ostatecznych wersji książki byłem akurat za granicą — pierwsze wydanie przesłałem z Capetown z Afryki Południowej, a drugie z Pragi — co nie byłoby możliwe bez zdobyczy wieku elektroniki. Wydania trzecie i czwarte ukończyłem w Crested Butte w Kolorado. Szczególne podziękowania dla wszystkich moich nauczycieli i uczniów (którzy są rów­ nocześnie moimi nauczycielami).

Przedmowa 27 Kiedy pracowałem nad tym wydaniem, moje kolana upodobała sobie kotka Molly — wypada i jej podziękować za ofiarowane mi ciepło. Lista wspierających mnie przyjaciół (choć nie jest ona zamknięta) to: Patty Gast (feno­ menalna masażystka), Andrew Binstock, Steve Sinofsky, JD Hildebrandt, Tom Keffer, Brian McElhinney, Brinkley Barr, Bill Gates z magazynu Midnight Engineering, Larry Constantine i Lucy Lockwood, Gene Wang, Dave Mayer, David Intersimone, Chris i Laura Strand, Almquistowie, Brad Jerbic, Marilyn Cvitanic, Mark Mabry i rodziny Robbin- sów i Moelterów (oraz McMillansowie), Michael Wilk, Dave Stoner, Cranstonowie, Lar­ ry Fogg, Mike Sequeira, Gary Entsminger, Kevin i Sonda Donovanowie, Joe Lordi, Dave i Brenda Bartlettowie, Blake, Annette & Jade, Rentschlerowie, Sudeksowie, Dick, Patty i Lee Eckel, Lynn i Todd z rodzinami. No i oczywiście Mama i Tata.

•.i,:'. ■’

Wprowadzenie „ On dał ludziom mową, a mowa stworzyła myśl, którajest miarą Wszechświata” — „Prometeusz rozpętany”, Shelly „Istoty ludzkie ... są pod wielkim wpływemjęzyka stosowanego jako środek wyrażania w ich środowisku. Złudzeniem jest wyobrażać sobie, że jednostka dostosowuje się do rzeczywistości właściwie bez użyciajęzyka —i żejęzyk jest tylko mało znaczącym środkiem rozwiązywania pewnych problemów komunikacji czy refleksji. Istotnyjestfakt, że „świat realny”jest w znacznej mierze nieświadomie budowany na baziejęzykowych nawyków grupy. ” „The Status O fLinguistics As A Science ”, Edward Sapir, 1929 I Podobnie jak dowolny język naturalny Java zapewnia możliwość definiowania pojęć. Jednak, gdy rozwiązywany problem będzie się stawał coraz większy i coraz bardziej skom­ plikowany, to w sprzyjających okolicznościach okaże się, że ta forma przekazu będzie znacznie łatwiejsza i bardziej elastyczna niż formy alternatywne. Nie można traktować Javy jako tylko zbioru cech — niektóre z nich osobno nie mają żadnego sensu. Możesz posłużyć się sumą tych części składowych tylko wtedy, kiedy myślisz o projektowaniu, a nie zwyczajnie o kodowaniu. Aby pojąć Javę w ten sposób, trzeba zrozumieć problemy w ujęciu języka oraz ogólnie pod kątem programowania. Ta książka omawia problemy programowania (skąd się biorą), jak również sposoby ich roz­ wiązywania z zastosowaniem Javy. Tak więc cechy, które opiszę w poszczególnych roz­ działach, oparte są na sposobie, w jaki postrzegamy konkretny rodzaj problemów poko­ nywanych z użyciem tego języka. Ten sposób, mam nadzieję, pozwoli osiągnąć Ci, drogi Czytelniku, stan, w którym świadomość Javy stanie się Twoim „naturalnym językiem”. Przez cały czas będę przyjmował, że chcesz zbudować w myślach pewien model, co po­ zwoli Ci dogłębnie zrozumieć język; jeżeli napotkasz problem, będziesz w stanie dopaso­ wać go do swojego modelu i znaleźć odpowiedź.