• Opanuj zasady projektowania obiektowego
• Wykorzystaj Javę do tworzenia aplikacji
• Zastosuj najnowsze narzędzia i techniki

Popularność Javy stale rośnie, a każda następna wersja tego języka wnosi coś nowego. Poznanie wszystkich możliwości drzemiących w Javie wymaga sięgnięcia do sprawdzonego źródła wiedzy -- książki "Thinking in Java". To światowy bestseller, który zyskał zasłużoną sławę najlepszego podręcznika do nauki Javy. Wzbudził entuzjazm i uznanie programistów przede wszystkim dzięki wyjątkowej przejrzystości, przemyślanej strukturze i trafnie dobranym przykładom.

Książka "Thinking in Java. Edycja polska. Wydanie IV" zawiera szczegółowe omówienie zasad programowania w Javie. Przeznaczona jest dla początkujących programistów i dla ekspertów. Przystępnie prezentuje zarówno zagadnienia podstawowe, jak i zaawansowane. Dziesiątki przykładów ułatwiają zrozumienie każdego tematu. Wszystko to sprawia, że poznajemy prawdziwą Javę -- uniwersalną, czytelną, niezależną od platformy systemowej. Czytając tę książkę, dowiesz się, co jest niezbędne do tworzenia wydajnych i bezpiecznych aplikacji w Javie.

• Projektowanie obiektowe
• Zasady dokumentowania kodu źródłowego
• Operatory i sterowanie przebiegiem wykonywania programu
• Inicjalizacja i usuwanie obiektów
• Kolekcje obiektów
• Obsługa błędów
• Operacje wejścia i wyjścia
• Programowanie współbieżne
• Projektowanie interfejsów użytkownika

Osoby które kupowały "Thinking in Java. Edycja polska. Wydanie IV", wybierały także:

• Zrozum struktury danych. Algorytmy i praca na danych w Javie 39,67 zł, (11,90 zł -70%)
• Wprowadzenie do Javy. Programowanie i struktury danych. Wydanie XII 193,23 zł, (59,90 zł -69%)
• Java. Najlepsze rozwiązania zadań programistycznych. Receptury. Wydanie IV 115,81 zł, (35,90 zł -69%)
• Programowanie w Javie. Solidna wiedza w praktyce. Wydanie XI 173,87 zł, (53,90 zł -69%)
• JavaFX. Kurs video. Wzorce oraz typy generyczne 79,00 zł, (31,60 zł -60%)

Spis treści

Thinking in Java. Edycja polska. Wydanie IV -- spis treści

Przedmowa (19)

Wprowadzenie (29)

Rozdział 1. Wprowadzenie w świat obiektów (37)

• Postępująca abstrakcja (38)
• Obiekt posiada interfejs (40)
• Obiekt dostarcza usługi (42)
• Ukrywanie implementacji (43)
• Wielokrotne wykorzystanie implementacji (44)
• Dziedziczenie (45)
  • "Bycie czymś" a "bycie podobnym do czegoś" (48)
• Wymienialność obiektów z użyciem polimorfizmu (49)
• Hierarchia z pojedynczym korzeniem (52)
• Kontenery (53)
  • Typy parametryzowane (typy ogólne) (54)
• Tworzenie obiektów i czas ich życia (55)
• Obsługa wyjątków - eliminowanie błędów (57)
• Współbieżność (57)
• Java i Internet (58)
  • Czym jest sieć WWW? (58)
  • Programowanie po stronie klienta (60)
  • Programowanie po stronie serwera (65)
• Podsumowanie (65)

Rozdział 2. 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)
  • Tablice w Javie (71)
• Nigdy nie ma potrzeby niszczenia obiektu (72)
  • Zasięg (72)
  • Zasięg obiektów (73)
• Własne typy danych - słowo class (74)
  • Pola i metody (74)
• Metody, argumenty i wartości zwracane (76)
  • Lista argumentów (76)
• Tworzenie programu w Javie (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)

Rozdział 3. 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 Javie nie ma "sizeof" (117)
• Kompendium operatorów (118)
• Podsumowanie (126)

Rozdział 4. Sterowanie przebiegiem wykonania (127)

• Prawda i fałsz (127)
• if-else (128)
• Iteracja (129)
  • do-while (129)
  • for (130)
  • Operator przecinka (131)
• Składnia foreach (132)
• return (134)
• break i continue (135)
• Niesławne "goto" (136)
• switch (140)
• Podsumowanie (142)

Rozdział 5. Inicjalizacja i sprzątanie (143)

• Gwarantowana inicjalizacja przez konstruktor (143)
• 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)
• Inicjalizacja tablic (173)
  • Zmienne listy argumentów (177)
• Typy wyliczeniowe (182)
• Podsumowanie (185)

Rozdział 6. 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)

Rozdział 7. 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)
• Słowo kluczowe final (229)
  • Zmienne finalne (229)
  • Metody finalne (233)
  • Klasy finalne (235)
  • Ostrożnie z deklaracją final (236)
• Inicjalizacja i ładowanie klas (237)
  • Inicjalizacja w przypadku dziedziczenia (238)
• Podsumowanie (239)

Rozdział 8. Polimorfizm (241)

• Rzutowanie w górę raz jeszcze (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 .new (299)
• Klasy wewnętrzne a rzutowanie w górę (300)
• Klasy wewnętrzne 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)
• 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 ListIterator (348)
• Klasa LinkedList (349)
• Klasa Stack (350)
• Interfejs Set (352)
• Interfejs Map (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)
  • Przekazywanie wyjątków na konsolę (418)
  • Zamiana wyjątków sprawdzanych na niesprawdzane (419)
• Wskazówki (421)
• Podsumowanie (421)

Rozdział 13. Ciągi znakó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 printf() (432)
  • System.out.format() (432)
  • Klasa Formatter (433)
  • Specyfikatory formatu (434)
  • Konwersje (435)
  • Metoda String.format() (438)
• Wyrażenia regularne (439)
  • Podstawy (440)
  • Tworzenie wyrażeń regularnych (442)
  • Kwantyfikatory (444)
  • Klasy Pattern 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 (465)

• 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 instanceof (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)

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żbie klasy Generator (531)
  • 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 samoskierowane (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)
• 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.fill() (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)
  • SortedMap (691)
  • LinkedHashMap (692)
• Haszowanie i kody haszujące (693)
  • Zasada działania hashCode() (696)
  • Haszowanie a szybkość (699)
  • Przesłonięcie metody hashCode() (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 Map (729)
  • Synchronizacja Collection i Map (730)
• 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ą FilterInputStream (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 Zip (799)
  • Archiwa Javy (JAR) (801)
• 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 testowaniu jednostkowym (886)
  • @Unit a typy ogólne (895)
  • Implementacja @Unit (896)
  • Usuwanie kodu testującego (903)
• Podsumowanie (905)

Rozdział 21. Współbieżność (907)

• Oblicza współbieżności (908)
  • Szybsze wykonanie (909)
  • Ulepszanie projektu (911)
• Podstawy wielowątkowości (912)
  • Definiowanie zadań (913)
  • Klasa Thread (914)
  • Wykonawcy (916)
  • 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 (936)
  • Przechwytywanie wyjątków (937)
• 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 notifyAll() (979)
  • notify() kontra notifyAll() (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 ReadWriteLock (1053)
• Obiekty aktywne (1055)
• Podsumowanie (1059)
  • Dalsza lektura (1061)

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)
  • FlowLayout (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)
  • Czym jest komponent JavaBean? (1136)
  • Wydobycie informacji o komponencie poprzez klasę Introspector (1138)
  • Bardziej 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)
• 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 (1164)
  • Instalowanie SWT (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 SWT (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)