Wprowadzenie

• Dla kogo jest przeznaczona ta książka? (18)
  
• Co sobie myśli Twój mózg? (19)
  
• Metapoznanie (21)
  
• Zmuś swój mózg do posłuszeństwa (23)
  
• Czego potrzebujesz, aby skorzystać z tej książki? (24)

Rozdział 1. Przełamując zalew początkowych trudności

• Jak działa Java? (28)
  
• Struktura kodu w Javie (31)
  
• Anatomia klasy (32)
  
• Metoda main() (33)
  
• Pętle (35)
  
• Rozgałęzienia warunkowe (test if) (37)
  
• Tworzenie aplikacji "99 butelek piwa" (38)
  
• Program krasomówczy (41)
  
• Pogawędki przy kominku - spór kompilatora z JVM (42)
  
• Ćwiczenia i zagadki (44)

Rozdział 2. Wycieczka do Obiektowa

• Wojna o fotel (Jurek "obiektowiec" kontra Bronek "proceduralny") (52)
  
• Dziedziczenie (wprowadzenie) (55)
  
• Przesłanianie metod (wprowadzenie) (56)
  
• Czym jest klasa? (metody, składowe) (58)
  
• Tworzenie pierwszego obiektu (60)
  
• Użycie metody main() (62)
  
• Kod od kuchni (63)
  
• Ćwiczenia i zagadki (66)

Rozdział 3. Poznaj swoje zmienne

• Deklarowanie zmiennej (Java zwraca uwagę na typ) (74)
  
• Typy podstawowe ("Poproszę podwójne z dodatkową pianką") (75)
  
• Słowa kluczowe Javy (77)
  
• Odwołania (zdalne sterowanie obiektami) (78)
  
• Deklarowanie i przypisywanie obiektów (79)
  
• Obiekty na automatycznie sprzątanej stercie (81)
  
• Tablice (pierwszy rzut oka) (83)
  
• Ćwiczenia i zagadki (87)

Rozdział 4. Jak działają obiekty?

• Metody wykorzystują stan obiektu (obiektowy pies szczeka inaczej) (97)
  
• Argumenty metod i typy zwracanych wartości (98)
  
• Przekazywanie przez wartość (zmienna zawsze jest kopiowana) (101)
  
• Metody pobierające i zapisujące (103)
  
• Hermetyzacja (użyj jej lub zaryzykuj upokorzenie) (104)
  
• Wykorzystanie odwołań w tablicy (107)
  
• Ćwiczenia i zagadki (112)

Rozdział 5. Supermocne metody

• Tworzenie gry Zatopić portal (120)
  
• Rozpoczynanie pracy nad prostą wersją gry Zatopić portal (122)
  
• Pisanie kodu przygotowawczego (pseudokodu gry) (123)
  
• Kod testowy prostej wersji gry (126)
  
• Pisanie kodu prostej wersji gry (127)
  
• Ostateczny kod prostej wersji gry Zatopić portal (130)
  
• Generowanie liczb losowych przy użyciu Math.random() (135)
  
• Gotowy kod do pobierania danych wpisywanych w wierszu poleceń (136)
  
• Realizacja cykliczna przy użyciu pętli for (138)
  
• Rzutowanie dużych typów prostych na mniejsze (140)
  
• Konwersje łańcuchów znaków na liczby przy użyciu Integer.parseInt() (140)
  
• Ćwiczenia i zagadki (141)

Rozdział 6. Korzystanie z biblioteki Javy

• Analizowanie błędu w prostej wersji gry Zatopić portal (148)
  
• ArrayList (wykorzystanie Java API) (154)
  
• Poprawa kodu klasy Portal (160)
  
• Tworzenie właściwej wersji gry (Zatopić portal) (162)
  
• Pseudokod właściwej wersji gry (166)
  
• Kod właściwej wersji gry (168)
  
• Wyrażenia logiczne (boolowskie) (173)
  
• Korzystanie z biblioteki (Java API) (176)
  
• Korzystanie z pakietów (instrukcja importu i pełne nazwy) (177)
  
• Korzystanie z dokumentacji w wersji HTML i literatury (180)
  
• Ćwiczenia i zagadki (182)

Rozdział 7. Wygodniejsze życie w Obiektowie

• Zrozumienie dziedziczenia (relacje między klasami nadrzędnymi i podrzędnymi) (188)
  
• Projektowanie drzewa dziedziczenia (symulacja na zwierzętach) (190)
  
• Unikanie powielania kodu (przy wykorzystaniu dziedziczenia) (191)
  
• Przesłanianie metod (192)
  
• JEST i MA (dziewczyna z wanną) (197)
  
• Co dziedziczysz po klasie nadrzędnej? (200)
  
• Co w rzeczywistości daje nam dziedziczenie? (202)
  
• Polimorfizm (używanie odwołania klasy nadrzędnej do obiektu klasy podrzędnej) (203)
  
• Reguły przesłaniania (nie dotykaj tych argumentów i typu wartości wynikowej) (210)
  
• Przeciążanie metody (powtórnie użyta nazwa metody, nic więcej) (211)
  
• Ćwiczenia i zagadki (213)

Rozdział 8. Poważny polimorfizm

• Obiektów niektórych klas po prostu nie należy tworzyć (220)
  
• Klasy abstrakcyjne (nie dają możliwości tworzenia obiektów) (221)
  
• Metody abstrakcyjne (muszą zostać zaimplementowane) (223)
  
• Polimorfizm w działaniu (226)
  
• Klasa Object (ostateczna klasa nadrzędna) (228)
  
• Odczytywanie obiektów z listy ArrayList (są odczytywane jako Object) (231)
  
• Kompilator sprawdza typy odwołań (nim pozwoli na wywołanie metody) (233)
  
• Połącz się ze swoim wewnętrznym Obiect-em (234)
  
• Odwołania polimorficzne (235)
  
• Rzutowanie odwołania do obiektu (przesuwanie się w dół drzewa dziedziczenia) (236)
  
• "Śmiertelny romb" (problem wielokrotnego dziedziczenia) (243)
  
• Wykorzystanie interfejsów (najlepsze rozwiązanie!) (244)
  
• Ćwiczenia i zagadki (249)

Rozdział 9. Życie i śmierć obiektu

• Stos i sterta, gdzie mieszkają zmienne i obiekty (256)
  
• Metody na stosie (257)
  
• Gdzie są przechowywane zmienne lokalne? (258)
  
• Gdzie są przechowywane składowe? (259)
  
• Cud uworzenia obiektu (260)
  
• Konstruktory (kod wykonywany, gdy powiemy: "Stań się") (261)
  
• Inicjalizacja stanu nowego obiektu Kaczka (263)
  
• Kompilator potrafi stworzyć konstruktor domyślny (bezargumentowy) (265)
  
• Konstruktory przeciążone (267)
  
• Konstruktory klas nadrzędnych (łańcuch wywołań konstruktorów) (270)
  
• Wywoływanie przeciążonych konstruktorów przy użyciu this() (276)
  
• Istnienie obiektu (278)
  
• Odśmiecanie (i zapewnianie przydatności obiektu) (280)
  
• Ćwiczenia i zagadki (287)

Rozdział 10. Liczby mają znaczenie

• Klasa Math (czy naprawdę potrzeba nam obiektu tej klasy?) (294)
  
• Metody statyczne (295)
  
• Zmienne statyczne (297)
  
• Stałe (statyczne zmienne sfinalizowane) (302)
  
• Metody klasy Math (random(), round(), abs() i inne) (306)
  
• Klasy "opakowujące" (Integer, Boolean, Character itd.) (307)
  
• Formatowanie liczb (310)
  
• Formatowanie dat (312)
  
• Ćwiczenia i zagadki (315)

Rozdział 11. Ryzykowne działania

• Tworzenie maszyny muzycznej (MuzMachina) (322)
  
• A co, jeśli trzeba wywołać potencjalnie niebezpieczny kod? (325)
  
• Wyjątki informują, że "mogło się stać coś złego" (326)
  
• Kompilator gwarantuje (sprawdza), że będziesz świadom zagrożeń (327)
  
• Przechwytywanie wyjątków przy użyciu try-catch (deskorolkarz) (328)
  
• Sterowanie przepływem w blokach try-catch (332)
  
• Blok finally (niezależnie od tego, co się dzieje, wyłącz piekarnik!) (333)
  
• Przechwytywanie wielu wyjątków (kolejność ma znaczenie) (335)
  
• Deklarowanie wyjątków (pomiń go) (341)
  
• Prawo obsługuj lub deklaruj (343)
  
• Kod od kuchni (generowanie dżwięków) (345)
  
• Ćwiczenia i zagadki (354)

Rozdział 12. Historia bardzo graficzna

• Twój pierwszy interfejs graficzny (359)
  
• Przechwytywanie zdarzeń generowanych przez użytkownika (361)
  
• Implementacja interfejsu odbiorcy (362)
  
• Przechwytywanie zdarzenia ActionEvent przycisku (364)
  
• Tworzenie interfejsu użytkownika wykorzystującego grafikę (367)
  
• Zabawa z metodą paintComponent() (369)
  
• Obiekt Graphics2D (370)
  
• Umieszczanie na ekranie więcej niż jednego przycisku (376)
  
• Pomoc ze strony klas wewnętrznych (stwórz odbiorcę jako klasę wewnętrzną) (382)
  
• Animacja (przesuń to, narysuj to, przesuń to, narysuj to i tak dalej) (386)
  
• Kod od kuchni (rysowanie przy dźwiękach muzyki) (390)
  
• Ćwiczenia i zagadki (398)

Rozdział 13. Popracuj nad Swingiem

• Komponenty biblioteki Swing (404)
  
• Menedżery układu (kontrolują wielkość i rozmieszczenie) (405)
  
• Trzy menedżery układu (BorderLayout, FlowLayout, BoxLayout) (407)
  
• BorderLayout (zarządza pięcioma regionami) (408)
  
• FlowLayout (zwraca uwagę na kolejność i preferowaną wielkość) (412)
  
• BoxLayout (podobny do poprzedniego, lecz może rozmieszczać elementy w pionie) (415)
  
• JTextField (służy do wpisywania pojedynczego wiersza tekstu) (417)
  
• JTextArea (służy do wpisywania wielu wierszy tekstu i ma możliwość jego przewijania) (418)
  
• JCheckBox (czy ta opcja jest wybrana?) (420)
  
• JList (lista elementów z możliwością przewijania) (421)
  
• Kod od kuchni (coś wielkiego - tworzenie klienta pogawędek aplikacji MuzMachina) (422)
  
• Ćwiczenia i zagadki (428)

Rozdział 14. Zapisywanie obiektów

• Stan obiektów biblioteki Swing (433)
  
• Zapisywanie zserializowanego obiektu do pliku (434)
  
• Strumienie wejścia-wyjścia w Javie (437)
  
• Serializacja obiektów (438)
  
• Implementacja intefejsu Serializable (439)
  
• Stosowanie zmiennych pomijanych podczas serialiacji (441)
  
• Deserializacja obiektów (443)
  
• Zapis zawartości pliku tekstowego (447)
  
• java.io.File (452)
  
• Odczyt zawartości pliku tekstowego (454)
  
• StringTokenizer (458)
  
• Kod od kuchni (462)
  
• Ćwiczenia i zagadki (466)

Rozdział 15. Nawiąż połączenie

• Ogólne omówienie programu klienta (473)
  
• Nawiązywanie połączenia, wysyłanie i odbieranie (474)
  
• Gniazda sieciowe (475)
  
• Porty TCP (476)
  
• Odczytywanie danych z gniazda (przy użyciu BufferedReader) (478)
  
• Zapisywanie danych w gnieździe (przy użyciu PrintWriter) (479)
  
• Pisanie programu CodziennePoradyKlient (480)
  
• Tworzenie prostego serwera (483)
  
• Kod aplikacji CodziennePoradySerwer (484)
  
• Tworzenie klienta pogawędek (486)
  
• Wiele stosów wywołań (490)
  
• Uruchamianie nowego wątku (utworzenie i rozpoczęcie działania) (492)
  
• Interfejs Runnable (zadanie, jakie wątek ma wykonać) (493)
  
• Trzy stany nowego obiektu Thread (nowy, uruchamialny, działający) (495)
  
• Pętla działania (496)
  
• Mechanizm szeregowania wątków (to on decyduje, a nie Ty) (497)
  
• Usypianie wątku (501)
  
• Tworzenie i uruchamianie dwóch wątków (503)
  
• Zagadnienia współbieżności - czy te problemy można rozwiązać? (505)
  
• Problem współbieżności Romka i Moniki (506)
  
• Blokowanie w celu stworzenia elementów atomowych (510)
  
• Każdy obiekt ma blokadę (511)
  
• Przerażający problem "utraconej modyfikacji" (512)
  
• Metody synchronizowane (przy użyciu blokowania) (514)
  
• Wzajemna blokada! (516)
  
• Kod wielowątkowego klienta pogawędek (518)
  
• Gotowy do użycia ProstyKlientPogawedek (520)
  
• Ćwiczenia i zagadki (524)

Rozdział 16. Rozpowszechnij swój kod

• Możliwości wdrażania (530)
  
• Niezależne przechowywanie kodu źródłowego i plików klasowych (532)
  
• Tworzenie wykonywalnych plików JAR (archiwów Javy) (533)
  
• Uruchamianie wykonywalnych plików JAR (534)
  
• Umieszczaj swoje klasy w pakietach! (535)
  
• Zapobieganie konfliktom nazw pakietów (536)
  
• Pakietom musi odpowiadać odpowiednia struktura katalogów (537)
  
• Kompilacja i uruchamianie programu, w którym wykorzystywane są pakiety (538)
  
• Kompilacja z opcją -d (539)
  
• Tworzenie wykonywalnych plików JAR (z wykorzystaniem pakietów) (540)
  
• Wdrażanie przez internet przy użyciu technologii JWS (ang. Java Web Start) (545)
  
• Plik .jnlp (547)
  
• Jak tworzyć i wdrażać aplikacje JWS? (548)
  
• Ćwiczenia i zagadki (549)

Rozdział 17. Przetwarzanie rozproszone

• Wywoływanie zdalnych metod (RMI), bardzo szczegółowy opis praktyczny (554-570)
  
• Serwlety (pobieżna prezentacja) (571)
  
• Enterprise JavaBeans (komponenty EJB, bardzo pobieżna prezentacja) (577)
  
• Jini, najlepsza z możliwych sztuczek (578)
  
• Tworzenie naprawdę fajnej, uniwersalnej przeglądarki usług (582)
  
• Koniec (594)

Dodatek A Ostatnie doprawianie kodu

• MuzMachinaKońcowa (kod klienta) (596)
  
• SerwerMuzyczny (kod serwera) (603)

Dodatek B Dziesięć najważniejszych zagadnień, które niemal znalazły się w tej książce...

• Operacje bitowe (606)
  
• Niezmienność (607)
  
• Asercje (608)
  
• Zasięg blokowy (609)
  
• Połączone wywołania (610)
  
• Przesłanianie metody equals() (611)
  
• Poziomy dostępu oraz modyfikatory dostępu (czyli co kto widzi) (612)
  
• Metody klas String oraz StringBuffer (614)
  
• Tablice wielowymiarowe (615)
  
• Kolekcje (616)

Skorowidz (625)