.:$$:.

Książka "Java. Receptury" zawiera kolekcję rozwiązań setek problemów, z którymi programiści używający języka Java spotykają się bardzo często. Receptury znajdują zastosowanie w szerokim spektrum zagadnień: od całkiem prostych, takich jak określanie zmiennej środowiskowej CLASSPATH, aż do całkiem złożonych programów pokazujących jak obsługiwać dokumenty XML lub wzbogacić swą aplikację o mechanizmy obsługi poczty elektronicznej.

Niezależnie od tego, jak planujesz wykorzystać tę książkę -- czy jako źródło pomysłów i inspiracji, czy też jako sposób poszerzenia swej wiedzy o języku Java -- zawsze będzie ona stanowić ważną część Twojej biblioteki. Mało która książka prezentuje tak wiele możliwości Javy oraz nauczy Cię praktycznego wykorzystania omawianych zagadnień.

W książce zostały omówione następujące zagadnienia:

• Kompilacja, uruchamianie oraz testowanie programów napisanych w Javie
• Interakcja ze środowiskiem
• Łańcuchy znaków oraz dopasowywanie wzorców
• Tablice oraz inne kolekcje danych
• Programowa obsługa portów szeregowych i równoległych
• Pliki, katalogi i system plików
• Tworzenie programów sieciowych pełniących funkcje klientów oraz serwerów
• Aplikacje internetowe, w tym także aplety
• Serwlety oraz dokumenty JSP
• Poczta elektroniczna
• Obsługa baz danych
• Wykorzystanie XML
• Programowanie rozproszone
• Introspekcja
• Tworzenie programów wielojęzycznych
• Wykorzystanie grafiki oraz dźwięku
• Tworzenie graficznego interfejsu użytkownika

Książka "Java. Receptury" jest idealną pozycją uzupełniającą dla programistów używających języka Java (lub książką podstawową dla osób, które Javy nauczyły się samodzielnie). Prezentuje ona wiele interfejsów programistycznych w sposób znacznie bardziej obszerny niż standardowe omówienie, dzięki czemu doskonale nadaje się dla osób potrzebujących szerszej znajomości Javy.

Ian F. Darwin ma trzydziestoletnie doświadczenia w tworzeniu oprogramowania i książek o programowaniu. Pracuje także jako instruktor oraz autor kursów w firmie Learning Tree Interanational.
Wstęp (15)
Rozdział 1. Rozpoczynanie pracy: kompilacja, uruchamianie i testowanie (31)

• 1.0. Wprowadzenie (31)
• 1.1. Kompilacja i uruchamianie programów napisanych w Javie - JDK (32)
• 1.2. Edycja i kompilacja programów przy użyciu edytorów wyposażonych w kolorowanie syntaktyczne (37)
  
• 1.3. Kompilacja, uruchamianie i testowanie programów przy użyciu IDE (39)
• 1.4. Wykorzystanie klas przedstawionych w niniejszej książce (44)
• 1.5. Automatyzacja kompilacji przy wykorzystaniu skryptu jr (45)
• 1.6. Automatyzacja procesu kompilacji przy użyciu programu make (46)
• 1.7. Automatyzacja kompilacji przy użyciu programu Ant (48)
• 1.8. Uruchamianie apletów (51)
• 1.9. Komunikaty o odrzuconych metodach (53)
• 1.10. Testowanie warunkowe bez użycia dyrektywy #ifdef (55)
• 1.11. Komunikaty testowe (57)
• 1.12. Wykorzystanie programu uruchomieniowego (58)
• 1.13. Testowanie jednostkowe - jak uniknąć konieczności stosowania programów uruchomieniowych? (60)
  
• 1.14. Dekompilacja plików klasowych Javy (63)
• 1.15. Zapobieganie możliwości dekompilacji plików klasowych Javy (65)
• 1.16. Uzyskiwanie czytelnych komunikatów o wyjątkach (66)
• 1.17. Poszukiwanie przykładowych kodów źródłowych (68)
• 1.18. Program Debug (70)

Rozdział 2. Interakcja ze środowiskiem (71)

• 2.0. Wprowadzenie (71)
• 2.1. Pobieranie wartości zmiennych środowiskowych (71)
• 2.2. Właściwości systemowe (73)
• 2.3. Tworzenie kodu zależnego od używanej wersji JDK (75)
• 2.4. Tworzenie kodu zależnego od używanego systemu operacyjnego (77)
• 2.5. Efektywne wykorzystanie zmiennej CLASSPATH (79)
• 2.6. Stosowanie rozszerzających interfejsów programistycznych lub API zapisanych w plikach JAR (82)
  
• 2.7. Analiza argumentów podanych w wierszu wywołania programu (83)

Rozdział 3. Łańcuchy znaków i przetwarzanie tekstów (89)

• 3.0. Wprowadzenie (89)
• 3.1. Odczytywanie fragmentów łańcucha (92)
• 3.2. Dzielenie łańcuchów znaków za pomocą obiektu klasy StringTokenizer (93)
• 3.3. Łączenie łańcuchów znaków przy użyciu operatora + i klasy StringBuffer (96)
• 3.4. Przetwarzanie łańcucha znaków po jednej literze (97)
• 3.5. Wyrównywanie łańcuchów znaków (98)
• 3.6. Konwersja pomiędzy znakami Unicode a łańcuchami znaków (101)
• 3.7. Odwracanie kolejności słów lub znaków w łańcuchu (102)
• 3.8. Rozwijanie i kompresja znaków tabulacji (104)
• 3.9. Kontrola wielkości liter (108)
• 3.10. Wcinanie zawartości dokumentów tekstowych (109)
• 3.11. Wprowadzanie znaków niedrukowalnych (111)
• 3.12. Usuwanie odstępów z końca łańcucha (112)
• 3.13. Przetwarzanie danych rozdzielonych przecinkami (113)
• 3.14. Program - proste narzędzie do formatowania tekstów (118)
• 3.15. Program - fonetyczne porównywanie nazwisk (120)

Rozdział 4. Dopasowywanie wzorców i wyrażenia regularne (125)

• 4.0. Wprowadzenie (125)
• 4.1. Składnia wyrażeń regularnych (128)
• 4.2. Jak wyrażenia regularne działają w praktyce? (130)
• 4.3. Wykorzystanie wyrażeń regularnych w języku Java (132)
• 4.4. Interaktywne testowanie wyrażeń regularnych (134)
• 4.5. Określanie tekstu pasującego do wzorca (135)
• 4.6. Zastępowanie określonego tekstu (136)
• 4.7. Wyświetlanie wszystkich wystąpień wzorca (137)
• 4.8. Wyświetlanie wierszy zawierających fragment pasujący do wzorca (139)
• 4.9. Kontrola wielkości znaków w metodach match() i subst() (141)
• 4.10. Prekompilacja wyrażeń regularnych (141)
• 4.11. Odnajdywanie znaków nowego wiersza (143)
• 4.12. Program - analizowanie danych (144)
• 4.13. Program - pełna wersja programu grep (146)

Rozdział 5. Liczby (151)

• 5.0. Wprowadzenie (151)
• 5.1. Sprawdzanie, czy łańcuch znaków stanowi poprawną liczbę (154)
• 5.2. Zapisywanie dużych wartości w zmiennych "mniejszych" typów (155)
• 5.3. Pobieranie ułamka z liczby całkowitej bez konwertowania go do postaci zmiennoprzecinkowej (156)
  
• 5.4. Wymuszanie zachowania dokładności liczb zmiennoprzecinkowych (158)
• 5.5. Porównywanie liczb zmiennoprzecinkowych (160)
• 5.6. Zaokrąglanie wartości zmiennoprzecinkowych (161)
• 5.7. Formatowanie liczb (162)
• 5.8. Konwersje pomiędzy różnymi systemami liczbowymi - dwójkowym, ósemkowym, dziesiętnym i szesnastkowym (165)
  
• 5.9. Operacje na grupie liczb całkowitych (166)
• 5.10. Posługiwanie się cyframi rzymskimi (167)
• 5.11. Formatowanie z zachowaniem odpowiedniej postaci liczby mnogiej (172)
• 5.12. Generowanie liczb losowych (173)
• 5.13. Generowanie lepszych liczb losowych (174)
• 5.14. Obliczanie funkcji trygonometrycznych (176)
• 5.15. Obliczanie logarytmów (176)
• 5.16. Mnożenie macierzy (177)
• 5.17. Operacje na liczbach zespolonych (179)
• 5.18. Obsługa liczb o bardzo dużych wartościach (181)
• 5.19. Program TempConverter (183)
• 5.20. Program - generowanie liczbowych palindromów (186)

Rozdział 6. Daty i godziny (191)

• 6.0. Wprowadzenie (191)
• 6.1. Określanie bieżącej daty (193)
• 6.2. Wyświetlanie daty i czasu w zadanym formacie (194)
• 6.3. Przedstawianie dat w innych systemach (196)
• 6.4. Konwersja liczb określających datę i czas na obiekt Calendar lub ilość sekund (197)
• 6.5. Analiza łańcuchów znaków i ich zamiana na daty (198)
• 6.6. Konwersja dat wyrażonych w formie sekund na obiekt Date (200)
• 6.7. Dodawanie i odejmowanie dat przy wykorzystaniu klas Date oraz Calendar (201)
• 6.8. Obliczanie różnic pomiędzy dwiema datami (202)
• 6.9. Porównywanie dat (203)
• 6.10. Określanie dnia tygodnia, miesiąca lub roku oraz numeru tygodnia (205)
• 6.11. Wyświetlanie kalendarza (207)
• 6.12. Czasomierze o dużej dokładności (209)
• 6.13. Wstrzymywanie wykonywania programu (211)
• 6.14. Program - usługa przypominająca (212)

Rozdział 7. Strukturalizacja danych w języku Java (215)

• 7.0. Wprowadzenie (215)
• 7.1. Strukturalizacja danych przy użyciu tablic (216)
• 7.2. Modyfikacja wielkości tablic (218)
• 7.3. Klasa podobna do tablicy, lecz bardziej dynamiczna (219)
• 7.4. Iteratory - dostęp do danych w sposób niezależny od ich typów (221)
• 7.5. Strukturalizacja danych przy wykorzystaniu list połączonych (223)
• 7.6. Odwzorowywanie przy wykorzystaniu klas Hashtable oraz HashMap (225)
• 7.7. Zapisywanie łańcuchów znaków w obiektach Properties i Preferences (226)
• 7.8. Sortowanie kolekcji (230)
• 7.9. Sortowanie w języku Java 1.1 (234)
• 7.10. Unikanie konieczności sortowania danych (235)
• 7.11. Zbiory (237)
• 7.12. Odnajdywanie obiektu w kolekcji (238)
• 7.13. Zamiana kolekcji na tablicę (240)
• 7.14. Tworzenie własnego iteratora (241)
• 7.15. Stos (243)
• 7.16. Struktury wielowymiarowe (244)
• 7.17. Kolekcje (246)
• 7.18. Program - porównanie szybkości działania (246)

Rozdział 8. Techniki obiektowe (251)

• 8.0. Wprowadzenie (251)
• 8.1. Wyświetlanie obiektów - formatowanie obiektów przy użyciu metody toString() (253)
• 8.2. Przesłanianie metody equals (255)
• 8.3. Przesłanianie metody hashCode (257)
• 8.4. Metoda clone (259)
• 8.5. Metoda finalize (261)
• 8.6. Wykorzystanie klas wewnętrznych (263)
• 8.7. Tworzenie metod zwrotnych przy wykorzystaniu interfejsów (264)
• 8.8. Polimorfizm i metody abstrakcyjne (268)
• 8.9. Przekazywanie wartości (270)
• 8.10. Zgłaszanie własnych wyjątków (273)
• 8.11. Program Plotter (274)

Rozdział 9. Wejście i wyjście (277)

• 9.0. Wprowadzenie (277)
• 9.1. Odczytywanie informacji ze standardowego strumienia wejściowego (282)
• 9.2. Zapis danych w standardowym strumieniu wyjściowym (285)
• 9.3. Otwieranie pliku o podanej nazwie (287)
• 9.4. Kopiowanie plików (287)
• 9.5. Odczytywanie zawartości pliku i zapisywanie jej w obiekcie String (291)
• 9.6. Zmiana skojarzeń strumieni standardowych (292)
• 9.7. Powielanie strumienia podczas realizacji operacji zapisu (293)
• 9.8. Odczyt i zapis danych zakodowanych w innym zbiorze znaków (296)
• 9.9. Te kłopotliwe znaki końca wiersza (297)
• 9.10. Kod operujący na plikach w sposób zależny od systemu operacyjnego (298)
• 9.11. Odczytywanie "podzielonych" wierszy tekstu (299)
• 9.12. Analiza zawartości pliku (304)
• 9.13. Dane binarne (309)
• 9.14. Przeszukiwanie (310)
• 9.15. Zapisywanie danych w strumieniu przy wykorzystaniu języka C (311)
• 9.16. Zapisywanie i odczytywanie serializowanych obiektów (313)
• 9.17. Unikanie wyjątków ClassCastException spowodowanych nieprawidłowymi wartościami SerialVersionUID (315)
• 9.18. Odczytywanie i zapisywanie danych w archiwach JAR oraz Zip (317)
• 9.19. Odczytywanie i zapisywanie plików skompresowanych (320)
• 9.20. Program - zamiana tekstu do postaci PostScript (322)
• 9.21. Program TarList (konwerter plików) (324)

Rozdział 10. Operacje na katalogach i systemie plików (337)

• 10.0. Wprowadzenie (337)
• 10.1. Pobieranie informacji o pliku (338)
• 10.2. Tworzenie pliku (341)
• 10.3. Zmiana nazwy pliku (342)
• 10.4. Usuwanie plików (342)
• 10.5. Tworzenie plików tymczasowych (344)
• 10.6. Zmiana atrybutów pliku (346)
• 10.7. Tworzenie listy zawartości katalogu (347)
• 10.8. Pobieranie katalogów głównych (349)
• 10.9. Tworzenie nowych katalogów (351)
• 10.10. Program Find (352)

Rozdział 11. Programowa obsługa portu szeregowego i równoległego (355)

• 11.0. Wprowadzenie (355)
• 11.1. Wybieranie portu (358)
• 11.2. Otwieranie portu szeregowego (361)
• 11.3. Otwieranie portu równoległego (365)
• 11.4. Rozwiązywanie konfliktów portów (368)
• 11.5. Odczyt i zapis - metoda krokowa (372)
• 11.6. Odczyt i zapis - przetwarzanie sterowane zdarzeniami (374)
• 11.7. Odczyt i zapis - wątki (378)
• 11.8. Program - obsługa plotera Penman (380)

Rozdział 12. Grafika i dźwięk (385)

• 12.0. Wprowadzenie (385)
• 12.1. Rysowanie przy użyciu obiektu Graphics (386)
• 12.2. Testowanie komponentów graficznych (387)
• 12.3. Wyświetlane tekstu (389)
• 12.4. Wyświetlanie wyśrodkowanego tekstu w komponencie (389)
• 12.5. Rysowanie cienia (391)
• 12.6. Wyświetlanie obrazu (393)
• 12.7. Odtwarzanie pliku dźwiękowego (398)
• 12.8. Prezentacja ruchomego obrazu (399)
• 12.9. Wyświetlanie tekstu przy użyciu biblioteki grafiki dwuwymiarowej (402)
• 12.10. Drukowanie - JDK 1.1 (405)
• 12.11. Drukowanie - Java 2 (408)
• 12.12. Program Ploter AWT (410)
• 12.13. Program Grapher (412)

Rozdział 13. Graficzny interfejs użytkownika (417)

• 13.0. Wprowadzenie (417)
• 13.1. Wyświetlanie komponentów graficznego interfejsu użytkownika (419)
• 13.2. Projektowanie układu okna (420)
• 13.3. Zakładki - nowe spojrzenie na świat (423)
• 13.4. Obsługa czynności - tworzenie działających przycisków (424)
• 13.5. Obsługa czynności przy wykorzystaniu anonimowych klas wewnętrznych (427)
• 13.6. Kończenie programu przy użyciu przycisku "Zamknij" (429)
• 13.7. Okna dialogowe - tego nie można zrobić później (434)
• 13.8. Wyświetlanie wyników wykonania programu w oknie (436)
• 13.9. Wybieranie plików przy użyciu klasy JFileChooser (439)
• 13.10. Wybieranie koloru (443)
• 13.11. Wyświetlanie okna głównego pośrodku ekranu (445)
• 13.12. Zmiana sposobów prezentacji programów pisanych z wykorzystaniem pakietu Swing (447)
  
• 13.13. Program - własne narzędzie do wybierania czcionek (451)
• 13.14. Program - własny menedżer układu (456)

Rozdział 14. Tworzenie programów wielojęzycznych oraz lokalizacja (463)

• 14.0. Wprowadzenie (463)
• 14.1. Tworzenie przycisku w różnych wersjach językowych (464)
• 14.2. Tworzenie listy dostępnych ustawień lokalnych (466)
• 14.3. Tworzenie menu przy wykorzystaniu zasobów wielojęzycznych (467)
• 14.4. Tworzenie metod pomocniczych, przydatnych przy tworzeniu programów wielojęzycznych (468)
• 14.5. Tworzenie okien dialogowych przy wykorzystaniu zasobów wielojęzycznych (470)
• 14.6. Tworzenie wiązki zasobów (471)
• 14.7. Przygotowywanie programów wielojęzycznych (473)
• 14.8. Wykorzystanie konkretnych ustawień lokalnych (474)
• 14.9. Określanie domyślnych ustawień lokalnych (475)
• 14.10. Formatowanie komunikatów (476)
• 14.11. Program MenuIntl (478)
• 14.12. Program BusCard (480)

Rozdział 15. Klienty sieciowe (485)

• 15.0. Wprowadzenie (485)
• 15.1. Nawiązywanie połączenia z serwerem (487)
• 15.2. Odnajdywanie i zwracanie informacji o adresach sieciowych (489)
• 15.3. Obsługa błędów sieciowych (490)
• 15.4. Odczyt i zapis danych tekstowych (491)
• 15.5. Odczyt i zapis danych binarnych (494)
• 15.6. Odczyt i zapis danych serializowanych (496)
• 15.7. Datagramy UDP (498)
• 15.8. Program - klient TFTP wykorzystujący protokół UDP (501)
• 15.9. Program - klient usługi Telnet (505)
• 15.10. Program - klient pogawędek internetowych (507)

Rozdział 16. Programy Javy działające na serwerze - gniazda (513)

• 16.0. Wprowadzenie (513)
• 16.1. Tworzenie serwera (514)
• 16.2. Zwracanie odpowiedzi (łańcucha znaków bądź danych binarnych) (517)
• 16.3. Zwracanie informacji o obiektach (521)
• 16.4. Obsługa wielu klientów (522)
• 16.5. Rejestracja operacji sieciowych (527)
• 16.6. Program - serwer pogawędek w Javie (531)

Rozdział 17. Klienty sieciowe II - aplety i klienty WWW (537)

• 17.0. Wprowadzenie (537)
• 17.1. Osadzanie apletów w stronach WWW (538)
• 17.2. Techniki tworzenia apletów (539)
• 17.3. Nawiązywanie połączenia z komputerem, z którego pobrano aplet (542)
• 17.4. Wyświetlanie dokumentu z poziomu apletu (545)
• 17.5. Uruchamianie skryptu CGI z poziomu apletu (547)
• 17.6. Odczyt zawartości zasobu wskazywanego przez adres URL (549)
• 17.7. Pobieranie znaczników HTML z dokumentu o podanym adresie URL (550)
• 17.8. Pobieranie adresów URL zapisanych w pliku (552)
• 17.9. Zamiana nazwy pliku na adres URL (554)
• 17.10. Program MkIndex (555)
• 17.11. Program LinkChecker (559)

Rozdział 18. Programy działające na serwerach - sewlety i JSP (567)

• 18.0. Wprowadzenie (567)
• 18.1. Pierwszy serwlet - generowanie strony WWW (569)
• 18.2. Serwlety - przetwarzanie danych przekazywanych z formularzy (572)
• 18.3. Cookies (575)
• 18.4. Śledzenie sesji (579)
• 18.5. Generowanie plików PDF przez serwlety (585)
• 18.6. Połączenie HTML-a i Javy - JSP (591)
• 18.7. Dołączanie plików i przekierowania w JSP (596)
• 18.8. Strony JSP wykorzystujące serwlety (597)
• 18.9. Upraszczanie kodu stron JSP dzięki wykorzystaniu komponentów JavaBeans (598)
• 18.10. Składnia JSP (603)
• 18.11. Program CookieCutter (603)
• 18.12. Program - portal informacyjny JabaDot (604)

Rozdział 19. Java i poczta elektroniczna (617)

• 19.0. Wprowadzenie (617)
• 19.1. Wysyłanie poczty elektronicznej - wersja działająca w przeglądarkach (618)
• 19.2. Wysyłanie poczty elektronicznej - właściwe rozwiązanie (622)
• 19.3. Dodawanie możliwości wysyłania poczty do programu działającego na serwerze (625)
• 19.4. Wysyłanie wiadomości MIME (631)
• 19.5. Tworzenie ustawień poczty elektronicznej (634)
• 19.6. Wysyłanie poczty elektronicznej bez użycia JavaMail (636)
• 19.7. Odczytywanie poczty elektronicznej (640)
• 19.8. Program MailReaderBean (645)
• 19.9. Program MailClient (648)

Rozdział 20. Dostęp do baz danych (659)

• 20.0. Wprowadzanie (659)
• 20.1. Baza danych składająca się z plików tekstowych (661)
• 20.2. Bazy danych DBM (666)
• 20.3. Konfiguracja i nawiązywanie połączeń JDBC (669)
• 20.4. Nawiązywanie połączenia z bazą danych JDBC (672)
• 20.5. Przesyłanie zapytań JDBC i pobieranie wyników (675)
• 20.6. Wykorzystanie sparametryzowanych poleceń JDBC (678)
• 20.7. Wykorzystanie procedur osadzonych w JDBC (682)
• 20.8. Modyfikacja danych przy użyciu obiektu ResultSet (683)
• 20.9. Modyfikacja danych przy użyciu poleceń SQL (685)
• 20.10. Odnajdywanie metadanych JDBC (687)
• 20.11. Program JDAdmin (693)

Rozdział 21. XML (699)

• 21.0. Wprowadzenie (699)
• 21.1. Przekształcanie danych XML przy użyciu XSLT (702)
• 21.2. Analiza składniowa XML przy użyciu API SAX (705)
• 21.3. Analiza dokumentów XML przy użyciu modelu obiektów dokumentu (DOM) (708)
• 21.4. Weryfikacja poprawności struktury przy wykorzystaniu DTD (710)
• 21.5. Generowanie własnego kodu XML przy wykorzystaniu DOM (711)
• 21.6. Program xml2mif (713)

Rozdział 22. Java w aplikacjach rozproszonych - RMI (717)

• 22.0. Wprowadzenie (717)
• 22.1. Definiowanie kontraktu RMI (719)
• 22.2. Klient RMI (721)
• 22.3. Serwer RMI (722)
• 22.4. Uruchamianie aplikacji RMI w sieci (725)
• 22.5. Program - wywołania zwrotne RMI (726)
• 22.6. Program RMIWatch (730)

Rozdział 23. Pakiety i ich tworzenie (737)

• 23.0. Wprowadzenie (737)
• 23.1. Tworzenie pakietu (738)
• 23.2. Tworzenie dokumentacji klas przy użyciu programu Javadoc (739)
• 23.3. Stosowanie programu archiwizującego jar (743)
• 23.4. Uruchamianie apletu zapisanego w pliku JAR (744)
• 23.5. Wykonywanie apletu przy użyciu JDK (745)
• 23.6. Uruchamianie programu zapisanego w pliku JAR (749)
• 23.7. Tworzenie klasy w taki sposób, by była komponentem JavaBean (749)
• 23.8. Umieszczanie komponentów w plikach JAR (753)
• 23.9. Umieszczanie serwletów w plikach JAR (754)
• 23.10. "Zapisz raz, instaluj wszędzie" (755)
• 23.11. Java Web Start (756)
• 23.12. Podpisywanie plików JAR (762)

Rozdział 24. Stosowanie wątków w Javie (765)

• 24.0. Wprowadzenie (765)
• 24.1. Uruchamianie kodu w innym wątku (767)
• 24.2. Animacja - wyświetlanie poruszających się obrazów (771)
• 24.3. Zatrzymywanie działania wątku (775)
• 24.4. Spotkania i ograniczenia czasowe (777)
• 24.5. Komunikacja między wątkami - kod synchronizowany (779)
• 24.6. Komunikacja między wątkami - metody wait() oraz notifyAll() (785)
• 24.7. Zapis danych w tle w programach edycyjnych (791)
• 24.8. Wielowątkowy serwer sieciowy (792)

Rozdział 25. Introspekcja lub "klasa o nazwie Class" (801)

• 25.0. Wprowadzenie (801)
• 25.1. Pobieranie deskryptora klasy (802)
• 25.2. Określanie i stosowanie metod i pól (803)
• 25.3. Dynamiczne ładowanie i instalowanie klas (807)
• 25.4. Tworzenie nowej klasy od podstaw (809)
• 25.5. Określanie efektywności działania (811)
• 25.6. Wyświetlanie informacji o klasie (815)
• 25.7. Program CrossRef (816)
• 25.8. Program AppletViewer (821)

Rozdział 26. Wykorzystywanie Javy wraz z innymi językami programowania (829)

• 26.0. Wprowadzenie (829)
• 26.1. Uruchamianie programu (830)
• 26.2. Wykonywanie programu i przechwytywanie jego wyników (833)
• 26.3. Wykorzystanie BSF do łączenia kodu Javy i skryptów (836)
• 26.4. Dołączanie kodu rodzimego (C/C++) (841)
• 26.5. Wywoływanie kodu Javy z kodu rodzimego (847)
• 26.6. Program DBM (848)

Posłowie (851)
Skorowidz (853)