"Najlepsza książka na temat Javy", "Jeden ze zdecydowanie najlepszych kursów Javy, jaki kiedykolwiek widziałem, dla jakiegokolwiek języka" -- to wybrane opinie o propozycji wydawnictwa Helion.

Książka zarówno dla początkujących, jak i ekspertów:

• Uczy języka Java, nie zaś mechanizmów zależnych od platformy systemowej.
• Poprzez omówienie podstaw wprowadza tematykę zaawansowaną.
• Omawia ponad 300 działających programów Javy, ponad 15 000 linii kodu.
• Dogłębnie objaśnienia zasady obiektowości oraz ich zastosowania w Javie.

Począwszy od podstaw składni Javy do jej najbardziej zaawansowanych właściwości (obliczenia rozproszone, zaawansowany potencjał obiektowy, wielowątkowość), książka ta została napisana przede wszystkim po to, by rozbudzić w początkującym programiście zainteresowanie Javą. Przystępny styl Bruce"a Eckela i ukierunkowane przykłady powodują, iż nawet najbardziej tajemnicze pojęcia stają się zrozumiałe.

Bruce Eckel jest autorem książki "Thinking in C++", która zdobyła nagrodę Software Development Jolt Award dla najlepszej książki 1995 roku. Programowaniem zajmuje się profesjonalnie od 20 lat. Uczy ludzi na całym świecie, jak programować z zastosowaniem obiektów już od 1986 roku, najpierw jako konsultant C++ a teraz Javy. Był członkiem Komitetu Standardów C++, napisał 5 innych książek na temat programowania zorientowanego obiektowego, wydał ponad 150 artykułów i prowadził felietony w wielu magazynach informatycznych. Stworzył ścieżkę C++, Javy i Pythona na konferencji Software Development Conference. Zdobył tytuł naukowy z zakresu Zastosowań Fizyki oraz tytuł magistra z zakresu Inżynierii Oprogramowania.

• Nagroda dla najlepszej książki przyznana przez czytelników JavaWorld w 2000 roku.
• Nagroda dla najlepszej książki przyznana przez redakcję Java Developer Journal, 1999.
• Nagroda za twórczość od Software Development Magazine, 1999.

 

Osoby które kupowały "Thinking in Java. Edycja polska", 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 -- spis treści

Wstęp (17)

Przedmowa (19)

• Przedmowa do wydania drugiego (21)
  
  • Java 2 (22)

Wprowadzenie (23)

• Warunki wstępne (23)
  
• Nauka Javy (24)
  
• Cele (24)
  
• Dokumentacja on-line (25)
  
• Zawartość rozdziałów (25)
  
• Ćwiczenia (30)
  
• Kody źródłowe (30)
  
  • Konwencje zapisu (31)
• Wersje Javy (32)
  
• Seminaria (32)
  
• Błędy (33)
  
• Projekt oryginalnej okładki (33)
  
• Podziękowania (33)
  
  • Współpracownicy internetowi (35)

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

• Postępująca abstrakcja (38)
  
• Obiekt posiada interfejs (39)
  
• Ukrywanie implementacji (41)
  
• Wielokrotne wykorzystanie implementacji (42)
  
• Dziedziczenie: wielokrotne użycie interfejsu (43)
  
  • Relacja "bycia czymś" a relacja "bycia podobnym do czegoś" (46)
• Wymienialność obiektów z użyciem polimorfizmu (47)
  
  • Abstrakcyjne klasy bazowe i interfejsy (50)
• Obiekty, sposób przechowywania i czas życia (51)
  
  • Kolekcje i iteratory (52)
  • Hierarchia z pojedynczym korzeniem (53)
  • Biblioteki kolekcji i ich stosowanie (54)
  • Dylemat domowy: kto powinien posprzątać? (55)
• Obsługa wyjątków - eliminowanie błędów (56)
  
• Wielowątkowość (57)
  
• Trwałość (58)
  
• Java i Internet (58)
  
  • Czym jest Internet? (58)
  • Programowanie po stronie klienta (60)
  • Programowanie po stronie serwera (65)
  • Osobny obszar: aplikacje (65)
• Analiza i projektowanie (66)
  
  • Etap 0. Zrób plan (68)
  • Etap 1. Co mamy stworzyć? (68)
  • Etap 2. Jak to zrobimy? (71)
  • Etap 3. Zbuduj jądro (74)
  • Etap 4. Przeglądaj przypadki użycia (74)
  • Etap 5. Ewolucja (75)
  • Planowanie popłaca (76)
• Programowanie ekstremalne (Extreme Programming) (77)
  
  • Najpierw napisz testy (77)
  • Programowanie w parach (78)
• Dlaczego Java odnosi sukcesy (79)
  
  • Systemy jest łatwiej opisać i zrozumieć (79)
  • Maksymalne zwiększenie wydajności dzięki bibliotekom (79)
  • Obsługa błędów (80)
  • Programowanie na wielką skalę (80)
• Strategie przejścia (80)
  
  • Wskazówki (80)
  • Problemy zarządzania (82)
• Java kontra C++ (83)
  
• Podsumowanie (84)

Rozdział 2. Wszystko jest obiektem (87)

• Dostęp do obiektów poprzez referencje (87)
  
• Wszystkie obiekty trzeba stworzyć (88)
  
  • Gdzie przechowujemy dane? (89)
  • Przypadek specjalny: typy podstawowe (90)
  • Tablice w Javie (91)
• Nigdy nie ma potrzeby niszczenia obiektu (92)
  
  • Zasięg (92)
  • Zasięg obiektów (92)
• Tworzenie nowych typów danych - klasa (93)
  
  • Pola i metody (94)
• Metody, argumenty i wartości zwracane (95)
  
  • Lista argumentów (96)
• Tworzenie programu w Javie (97)
  
  • Widoczność nazw (97)
  • Wykorzystanie innych komponentów (98)
  • Słowo kluczowe static (99)
• Twój pierwszy program w Javie (100)
  
  • Kompilacja i uruchomienie (101)
• Komentarze oraz dokumentowanie kodu (102)
  
  • Dokumentacja w komentarzach (103)
  • Składnia (103)
  • Osadzony HTML (104)
  • @see: odwołanie do innych klas (104)
  • Znaczniki dokumentowania klas (105)
  • Znaczniki dokumentacji zmiennych (105)
  • Znaczniki dokumentacji metod (105)
  • Przykład dokumentowania kodu (106)
• Styl programowania (107)
  
• Podsumowanie (108)
  
• Ćwiczenia (108)

Rozdział 3. Sterowanie kolejnością wykonania (109)

• Używanie operatorów Javy (109)
  
  • Kolejność (109)
  • Przypisanie (110)
  • Operatory matematyczne (112)
  • Operatory zwiększania i zmniejszania (114)
  • Operatory relacji (115)
  • Operatory logiczne (116)
  • Operatory bitowe (118)
  • Operatory przesunięcia (119)
  • Operator trójargumentowy if-else (122)
  • Przecinek (123)
  • Łańcuchowy operator + (123)
  • Najczęstsze pułapki przy używaniu operatorów (124)
  • Operatory rzutowania (124)
  • W Javie nie ma "sizeof" (127)
  • Powtórka z kolejności operatorów (127)
  • Kompendium operatorów (128)
• Sterowanie wykonaniem (136)
  
  • Prawda i fałsz (136)
  • If-else (136)
  • Iteracja (137)
  • Do-while (138)
  • For (138)
  • Break i continue (140)
  • Switch (144)
• Podsumowanie (148)
  
• Ćwiczenia (148)

Rozdział 4. Inicjalizacja i sprzątanie (149)

• Gwarantowana inicjalizacja przez konstruktor (149)
  
• Przeciążanie metod (151)
  
  • Rozróżnianie przeciążonych metod (153)
  • Przeciążanie a typy podstawowe (153)
  • Przeciążanie przez wartości zwracane (156)
  • Konstruktory domyślne (157)
  • Słowo kluczowe this (157)
• Sprzątanie: finalizacja i odśmiecanie pamięci (160)
  
  • Do czego służy finalize()? (161)
  • Musimy przeprowadzić sprzątanie (162)
  • Warunek śmierci (165)
  • Jak działa odśmiecacz pamięci (166)
• Inicjalizacja składowych (169)
  
  • Określanie sposobu inicjalizacji (170)
  • Inicjalizacja w konstruktorze (171)
• Inicjalizacja tablic (176)
  
  • Tablice wielowymiarowe (180)
• Podsumowanie (183)
  
• Ćwiczenia (183)

Rozdział 5. Ukrywanie implementacji (185)

• Pakiet - jednostka biblioteczna (186)
  
  • Tworzenie unikatowych nazw pakietów (187)
  • Własna biblioteka narzędziowa (190)
  • Wykorzystanie instrukcji import do zmiany zachowania (191)
  • Pułapka związana z pakietami (193)
• Modyfikatory dostępu w Javie (193)
  
  • Dostęp "przyjazny" (193)
  • Public: dostęp do interfejsu (194)
  • Private: nie dotykać! (196)
  • Protected: "pewien rodzaj przyjacielskości" (197)
• Interfejs i implementacja (198)
  
• Dostęp do klas (199)
  
• Podsumowanie (202)
  
• Ćwiczenia (203)

Rozdział 6. Wielokrotne wykorzystanie klas (205)

• Składnia kompozycji (205)
  
• Składnia dziedziczenia (208)
  
  • Inicjalizacja klasy bazowej (210)
• Łączenie kompozycji i dziedziczenia (212)
  
  • Zapewnienie poprawnego sprzątania (213)
  • Ukrywanie nazw (216)
• Wybór między kompozycją a dziedziczeniem (217)
  
• protected (218)
  
• Przyrostowe tworzenie oprogramowania (219)
  
• Rzutowanie w górę (219)
  
  • Dlaczego "w górę"? (220)
• Słowo kluczowe final (221)
  
  • Zmienne ostateczne (221)
  • Metody ostateczne (225)
  • Klasy ostateczne (226)
• Inicjalizacja i ładowanie klas (228)
  
  • Inicjalizacja w przypadku dziedziczenia (228)
• Podsumowanie (229)
  
• Ćwiczenia (230)

Rozdział 7. Polimorfizm (233)

• Rzutowanie w górę raz jeszcze (233)
  
  • Zapominanie o typie obiektu (234)
• Mały trik (236)
  
  • Wiązanie wywołania metody (236)
  • Uzyskiwanie poprawnego działania (237)
  • Rozszerzalność (239)
• Przesłanianie kontra przeciążanie (242)
  
• Klasy i metody abstrakcyjne (243)
  
• Konstruktory a polimorfizm (246)
  
  • Kolejność wywołań konstruktorów (246)
  • Dziedziczenie a metoda finalize() (248)
  • Zachowanie się metod polimorficznych wewnątrz konstruktorów (251)
• Projektowanie z użyciem dziedziczenia (253)
  
  • Czyste dziedziczenie kontra rozszerzanie (254)
  • Rzutowanie w dół a identyfikacja typu w czasie wykonania (255)
• Podsumowanie (257)
  
• Ćwiczenia (257)

Rozdział 8. Interfejsy i klasy wewnętrzne (259)

• Interfejsy (259)
  
  • "Wielokrotne dziedziczenie" w Javie (262)
  • Rozszerzanie interfejsu poprzez dziedziczenie (265)
  • Grupowanie stałych (266)
  • Inicjalizacja pól interfejsów (267)
  • Zagnieżdżanie interfejsów (268)
• Klasy wewnętrzne (270)
  
  • Klasy wewnętrzne a rzutowanie w górę (272)
  • Klasy wewnętrzne w metodach i zakresach (274)
  • Anonimowe klasy wewnętrzne (276)
  • Połączenie z klasą zewnętrzną (278)
  • Statyczne klasy wewnętrzne (280)
  • Odwoływanie się do obiektu klasy zewnętrznej (282)
  • Sięganie na zewnątrz z klasy wielokrotnie zagnieżdżonej (283)
  • Dziedziczenie po klasach wewnętrznych (283)
  • Czy klasy wewnętrzne mogą być przesłaniane? (284)
  • Identyfikatory klas wewnętrznych (286)
  • Dlaczego klasy wewnętrzne? (286)
  • Domknięcia i wywołania zwrotne (289)
  • Klasy wewnętrzne a szkielety sterowania (291)
• Podsumowanie (297)
  
• Ćwiczenia (297)

Rozdział 9. Przechowywanie obiektów (301)

• Tablice (301)
  
  • Tablice to obiekty (302)
  • Tablice jako wartości zwracane (305)
  • Klasa Arrays (306)
  • Wypełnianie tablicy (315)
  • Kopiowanie tablic (316)
  • Porównywanie tablic (317)
  • Porównywanie elementów tablic (318)
  • Sortowanie tablic (321)
  • Przeszukiwanie tablicy posortowanej (322)
  • Podsumowanie wiadomości o tablicach (323)
• Wprowadzenie do kontenerów (324)
  
  • Wypisanie zawartości kontenerów (325)
  • Wypełnianie kontenerów (326)
• Wada kontenera: nieznany typ (331)
  
  • Czasami mimo wszystko działa (333)
  • Tworzenie świadomej typu klasy ArrayList (334)
• Iteratory (335)
  
• Rodzaje kontenerów (338)
  
• Interfejs Collection (341)
  
• Interfejs List (343)
  
  • Stos na podstawie LinkedList (346)
  • Kolejka na podstawie LinkedList (347)
• Interfejs Set (348)
  
  • SortedSet (350)
• Interfejs Map (350)
  
  • SortedMap (354)
  • Haszowanie i kody haszujące (354)
  • Przesłonięcie metody hashCode() (361)
• Przechowywanie referencji (363)
  
  • WeakHashMap (365)
• Iteratory ponownie (367)
  
• Wybór implementacji (368)
  
  • Wybór między listami (368)
  • Wybór implementacji zbioru (371)
  • Wybór implementacji odwzorowania (373)
• Sortowanie i przeszukiwanie list (375)
  
• Dodatkowe usługi (375)
  
  • Niemodyfikowalne kontenery Collection i Map (376)
  • Synchronizacja Collection i Map (377)
• Nie wspierane operacje (378)
  
• Kontenery Java 1.0 i 1.1 (380)
  
  • Vector i Enumeration (381)
  • Hashtable (382)
  • Stack (382)
  • BitSet (383)
• Podsumowanie (384)
  
• Ćwiczenia (385)

Rozdział 10. Obsługa błędów za pomocą wyjątków (389)

• Podstawy obsługi wyjątków (390)
  
  • Parametry wyjątków (391)
• Przechwytywanie wyjątku (391)
  
  • Blok try (392)
  • Obsługa wyjątków (392)
• Tworzenie własnych wyjątków (393)
  
• Specyfikacja wyjątków (396)
  
  • Przechwytywanie dowolnego wyjątku (397)
  • Ponowne wyrzucanie wyjątków (399)
• Standardowe wyjątki Javy (402)
  
  • Specjalny przypadek RuntimeException (402)
• Robienie porządków w finally (404)
  
  • Do czego służy finally? (405)
  • Pułapka: zagubiony wyjątek (407)
• Ograniczenia wyjątków (408)
  
• Konstruktory (411)
  
• Dopasowywanie wyjątków (414)
  
  • Wskazówki (415)
• Podsumowanie (416)
  
• Ćwiczenia (416)

Rozdział 11. System wejścia-wyjścia w Javie (419)

• Klasa File (419)
  
  • Wypisywanie zawartości katalogu (420)
  • Operacje na katalogach (423)
• Wejście i wyjście (425)
  
  • Typy InputStream (425)
  • Typy OutputStream (427)
• Dodawanie atrybutów i użytecznych interfejsów (428)
  
  • Czytanie z InputStream za pomocą FilterInputStream (428)
  • Zapis do OutputStream za pomocą FilterOutputStream (429)
• Czytelnicy i pisarze (431)
  
  • Źródła i ujścia danych (431)
  • Modyfikacja zachowania strumienia (432)
  • Klasy nie zmienione (433)
• Osobna i samodzielna RandomAccessFile (433)
  
• Typowe zastosowania strumieni I/O (434)
  
  • Strumienie wejścia (436)
  • Strumienie wyjścia (438)
  • Błąd w bibliotece? (439)
  • Strumienie typu "pipe" (440)
• Standardowe wejście-wyjście (440)
  
  • Czytanie ze standardowego wejścia (441)
  • Zamiana System.out na PrintWriter (441)
  • Przekierowywanie standardowego wejścia-wyjścia (442)
• Kompresja (443)
  
  • Prosta kompresja do formatu GZIP (444)
  • Przechowywanie wielu plików w formacie Zip (445)
  • Archiwa Javy (JAR) (447)
• Serializacja obiektów (448)
  
  • Odnajdywanie klasy (452)
  • Kontrola serializacji (453)
  • Stosowanie trwałości (460)
• Atomizacja wejścia (466)
  
  • StreamTokenizer (466)
  • StringTokenizer (469)
  • Sprawdzanie poprawności stylu (471)
• Podsumowanie (477)
  
• Ćwiczenia (478)

Rozdział 12. Identyfikacja typu w czasie wykonania (481)

• Potrzeba mechanizmu RTTI (481)
  
  • Obiekt Class (483)
  • Sprawdzanie przed rzutowaniem (486)
• Składnia RTTI (492)
  
• Odzwierciedlenia - informacja o klasie w czasie wykonania (494)
  
  • Ekstraktor metod klasowych (495)
• Podsumowanie (499)
  
• Ćwiczenia (500)

Rozdział 13. Tworzenie okienek i apletów (503)

• Podstawy tworzenia apletów (505)
  
  • Ograniczenia apletów (505)
  • Zalety apletów (506)
  • Szkielet aplikacji (506)
  • Uruchamianie apletów w przeglądarce internetowej (507)
  • Wykorzystanie programu Appletviewer (509)
  • Testowanie apletów (509)
• Uruchamianie apletów z wiersza poleceń (510)
  
  • Platforma prezentacyjna (512)
  • Wykorzystanie Windows Explorer (514)
• Tworzenie przycisku (514)
  
• Przechwytywanie zdarzenia (515)
  
• Pola tekstowe (518)
  
• Rozmieszczenie komponentów (519)
  
  • BorderLayout (519)
  • FlowLayout (520)
  • GridLayout (521)
  • GridBagLayout (522)
  • Bezpośrednie pozycjonowanie (522)
  • BoxLayout (522)
  • Najlepsze rozwiązanie? (525)
• Model zdarzeń w Swingu (526)
  
  • Rodzaje zdarzeń i odbiorców (526)
  • Śledzenie wielu zdarzeń (531)
• Katalog komponentów Swing (534)
  
  • Przyciski (534)
  • Ikony (537)
  • Podpowiedzi (538)
  • Pola tekstowe (538)
  • Ramki (540)
  • Panele z paskami przewijania (541)
  • Miniedytor (543)
  • Pola wyboru (544)
  • Przyciski wyboru (545)
  • Listy rozwijalne (546)
  • Listy (547)
  • Zakładki (549)
  • Okienka komunikatów (550)
  • Menu (552)
  • Menu kontekstowe (557)
  • Rysowanie (558)
  • Okienka dialogowe (561)
  • Okienka dialogowe plików (564)
  • HTML w komponentach Swing (566)
  • Suwaki i paski postępu (567)
  • Drzewa (568)
  • Tabele (570)
  • Zmiana wyglądu aplikacji (571)
  • Schowek (573)
• Pakowanie apletu do pliku JAR (576)
  
• Techniki programowania (576)
  
  • Dynamiczne dołączanie zdarzeń (577)
  • Oddzielenie logiki biznesowej od interfejsu użytkownika (578)
  • Postać kanoniczna (580)
• Programowanie wizualne i Beany (581)
  
  • Czym jest Bean? (582)
  • Wydobycie informacji o Beanie poprzez introspektor (584)
  • Bardziej wyszukany Bean (589)
  • Pakowanie Beana (592)
  • Bardziej złożone wsparcie dla Beanów (593)
  • Więcej o Beanach (594)
• Podsumowanie (594)
  
• Ćwiczenia (595)

Rozdział 14. Wielowątkowość (599)

• Interaktywny interfejs użytkownika (599)
  
  • Dziedziczenie z klasy Thread (601)
  • Wielowątkowość do budowy interaktywnego interfejsu (603)
  • Połączenie wątku z klasą główną (605)
  • Tworzenie wielu wątków (607)
  • Wątki demony (609)
• Współdzielenie ograniczonych zasobów (611)
  
  • Niewłaściwy dostęp do zasobów (611)
  • Jak Java współdzieli zasoby (615)
  • JavaBeans w innym wydaniu (619)
• Blokowanie (623)
  
  • Zablokowanie (623)
  • Impas (632)
• Priorytety (636)
  
  • Odczyt i ustawienie priorytetów (636)
  • Grupy wątków (639)
• Runnable (645)
  
  • Zbyt wiele wątków (648)
• Podsumowanie (650)
  
• Ćwiczenia (652)

Rozdział 15. Przetwarzanie rozproszone (655)

• Programowanie sieciowe (656)
  
  • Identyfikowanie maszyny (656)
  • Gniazda (659)
  • Obsługa wielu klientów (664)
  • Datagramy (669)
  • Więcej o sieciach (671)
• Java DataBase Connectivity (JDBC) (671)
  
  • Uruchamianie przykładu (674)
  • Wersja programu wyszukującego z interfejsem graficznym (677)
  • Dlaczego interfejs JDBC wydaje się tak skomplikowany (679)
  • Bardziej wyrafinowany przykład (680)
• Serwlety (686)
  
  • Podstawowy serwlet (687)
  • Serwlety a wielowątkowość (690)
  • Obsługiwanie sesji w serwletach (691)
  • Uruchamianie przykładowych serwletów (695)
• Java Server Pages (695)
  
  • Obiekty niejawne (696)
  • Dyrektywy JSP (697)
  • Elementy skryptowe JSP (698)
  • Wydobywanie pól i ich wartości (700)
  • Atrybuty strony JSP oraz zasięg ich ważności (701)
  • Manipulowanie sesjami z poziomu stron JSP (702)
  • Tworzenie i modyfikowanie ciasteczek (703)
  • Podsumowanie tematu JSP (704)
• RMI (Remote Method Invocation) (705)
  
  • Odległe interfejsy (705)
  • Implementacja odległego interfejsu (706)
  • Tworzenie namiastki i szkieletu (708)
  • Użycie odległego obiektu (709)
• CORBA (710)
  
  • Podstawy CORBA (710)
  • Przykład (712)
  • Aplety Javy i CORBA (716)
  • CORBA a RMI (716)
• Enterprise JavaBeans (717)
  
  • JavaBeans a EJB (718)
  • Specyfikacja EJB (718)
  • Komponenty EJB (718)
  • Części komponentu EJB (720)
  • Działanie EJB (721)
  • Rodzaje EJB (721)
  • Tworzenie EJB (722)
  • Podsumowanie EJB (726)
• Jini - serwisy rozproszone (726)
  
  • Zadania Jini (726)
  • Co to jest Jini? (727)
  • Jak to działa (728)
  • Proces odkrywania (728)
  • Proces dołączenia (728)
  • Proces lokalizacji (729)
  • Rozdzielenie interfejsu od implementacji (730)
  • Abstrakcja systemów rozproszonych (730)
• Podsumowanie (731)
  
• Ćwiczenia (731)

Dodatki (733)

Dodatek A Przekazywanie i zwracanie obiektów (735)

• Przekazywanie referencji (735)
  
  • Odnośniki (736)
• Tworzenie kopii lokalnych (738)
  
  • Przekazywanie przez wartość (738)
  • Klonowanie obiektów (739)
  • Dodanie klonowalności do klasy (740)
  • Udane klonowanie (741)
  • Działanie Object.clone() (743)
  • Klonowanie złożonego obiektu (745)
  • Głęboka kopia ArrayList (747)
  • Głęboka kopia poprzez serializację (748)
  • Dodanie klonowalności w dół hierarchii (750)
  • Czemu takie dziwne rozwiązanie? (751)
• Sterowanie klonowalnością (751)
  
  • Konstruktor kopiujący (755)
• Klasy tylko do odczytu (759)
  
  • Tworzenie klas tylko do odczytu (760)
  • Wada obiektów odpornych na zmiany (761)
  • Niezmienne obiekty String (763)
  • Klasy String i StringBuffer (765)
  • Stringi są wyjątkowe (768)
• Podsumowanie (768)
  
• Ćwiczenia (769)

Dodatek B Java Native Interface (JNI) (771)

• Wywołanie metody rodzimej (772)
  
  • Generator pliku nagłówkowego - javah (772)
  • Maglowanie nazw i sygnatury funkcji (773)
  • Implementacja biblioteki dynamicznej (773)
• Dostęp do funkcji JNI: argument JNIEnv (774)
  
  • Dostęp do obiektów typu String (775)
• Przekazywanie i używanie obiektów Javy (775)
  
• JNI i wyjątki Javy (777)
  
• JNI a wątki (778)
  
• Wykorzystanie istniejącego kodu (778)
  
• Dodatkowe informacje (778)

Dodatek C Wskazówki dla programistów (779)

• Projekt (779)
  
• Implementacja (783)

Dodatek D Zasoby (789)

• Oprogramowanie (789)
  
• Książki (789)
  
  • Analiza i projektowanie (790)
  • Python (792)
  • Lista moich książek (792)

Skorowidz (795)