• Nagroda dla najlepszej książki przyznana przez redakcję JavaWorld w roku 2001.
• Nagroda dla najlepszej książki przyznana przez czytelników JavaWorld w roku 2000.
• Nagroda od Software Development Magazine w roku 1999.
• Nagroda dla najlepszej książki przyznana przez redakcję Java Developer"s Journal w roku 1998.

Książka "Thinking in Java" wzbudziła entuzjazm i uznanie programistów na całym świecie przede wszystkim dzięki swej wyjątkowej przejrzystości, przemyślanej i uważnej organizacji oraz krótkim, trafnie dobranym przykładom. Książka obejmuje szeroki zakres tematów -- zaczynając od podstaw składni Javy, a kończąc na najbardziej zaawansowanych zagadnieniach (dokładny opis pojęć obiektowych, wielowątkowości, zautomatyzowane konstruowanie, testowanie modułów oraz wykrywanie i usuwanie błędów).

• Wprowadzenie do języka Java uaktualnione o prezentację nowych możliwości wprowadzonych w JDK 1.4
• Nowy program testowy weryfikujący poprawność działania każdego z programów i prezentujący generowane przez niego wyniki
• Nowy rozdział poświęcony testowaniu modułów, zautomatyzowanemu konstruowaniu programów, asercjom, rejestracji oraz innym sposobom zapewniania poprawności programów
• Całkowicie zmodyfikowany rozdział poświęcony wielowątkowości pozwalający dobrze poznać podstawy tego zagadnienia
• Ponad 350 działających przykładów uaktualnionych z myślą o niniejszym wydaniu książki; ponad 15 tysięcy wierszy kodu
• Książka zarówno dla początkujących, jak i ekspertów
• Uczy języka Java, a nie rozwiązań zależnych od platformy systemowej
• Szczegółowo omawia podstawowe zagadnienia, nie pomija bardziej zaawansowanych
• Dogłębnie wyjaśnia zasady obiektowości oraz ich zastosowanie w Javie

O autorze:
Bruce Eckel jest prezesem MindView, Inc., firmy prowadzącej zarówno otwarte jak i zamknięte kursy treningowe; zajmującej się też doradztwem, nadzorem i kontrolą nad projektami związanymi z technologiami obiektowymi i wzorcami projektowymi. [więcej...]

 

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

• Wprowadzenie do Javy. Programowanie i struktury danych. Wydanie XII 193,23 zł, (59,90 zł -69%)
• Spring i Spring Boot. Kurs video. Testowanie aplikacji i bezpiecze 129,00 zł, (51,60 zł -60%)
• Metoda dziel i zwyci 89,00 zł, (35,60 zł -60%)
• JavaFX. Kurs video. Wzorce oraz typy generyczne 79,00 zł, (31,60 zł -60%)
• Platforma Xamarin. Kurs video. Poziom drugi. Zaawansowane techniki tworzenia aplikacji cross-platform 99,00 zł, (39,60 zł -60%)

• 
• 
• 
• 
• 

Spis treści

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

Podziękowania (17)

Przedmowa (21)

• Przedmowa do wydania trzeciego (23)
  
• Java 2, JDK 1.4 (25)

Wprowadzenie (27)

• Warunki wstępne (27)
  
• Nauka Javy (28)
  
• Cele (29)
  
• Dokumentacja online (29)
  
• Zawartość rozdziałów (30)
  
• Ćwiczenia (35)
  
• Kody źródłowe (35)
  
  • Konwencje zapisu (37)
• Wersje Javy (37)
  
• Błędy (37)
  
• Projekt okładki (38)

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

• Postępująca abstrakcja (40)
  
• Obiekt posiada interfejs (41)
  
• Obiekt dostarcza usług (44)
  
• Ukrywanie implementacji (45)
  
• Wielokrotne wykorzystanie implementacji (46)
  
• Dziedziczenie: wielokrotne użycie interfejsu (47)
  
  • "Bycie czymś" a "bycie podobnym do czegoś" (50)
• Wymienialność obiektów z użyciem polimorfizmu (51)
  
  • Abstrakcyjne klasy bazowe i interfejsy (54)
• Tworzenie obiektów, sposób ich stosowania i czas życia (55)
  
  • Kolekcje i iteratory (56)
  • Hierarchia z pojedynczym korzeniem (57)
  • Rzutowanie w dół kontra wzorce (generalia) (58)
  • Zapewnienie odpowiedniego "sprzątania" (59)
• Obsługa wyjątków - eliminowanie błędów (60)
  
• Współbieżność (61)
  
• Trwałość (62)
  
• Java i Internet (63)
  
  • Czym jest Internet? (63)
  • Programowanie po stronie klienta (64)
  • Programowanie po stronie serwera (70)
  • Aplikacje (71)
• Dlaczego Java odnosi sukcesy (71)
  
  • Systemy jest łatwiej opisać i zrozumieć (71)
  • Maksymalne zwiększenie wydajności dzięki bibliotekom (72)
  • Obsługa błędów (72)
  • Programowanie na wielką skalę (72)
• Java kontra C++ (73)
  
• Podsumowanie (74)

Rozdział 2. Wszystko jest obiektem (75)

• Dostęp do obiektów poprzez referencje (75)
  
• Wszystkie obiekty trzeba stworzyć (76)
  
  • Gdzie przechowujemy dane (77)
  • Przypadek specjalny: typy podstawowe (78)
  • Tablice w Javie (79)
• Nigdy nie ma potrzeby niszczenia obiektu (80)
  
  • Zasięg (80)
  • Zasięg obiektów (81)
• Tworzenie nowych typów danych - klasa (82)
  
  • Pola i metody (82)
• Metody, argumenty i wartości zwracane (84)
  
  • Lista argumentów (85)
• Tworzenie programu w Javie (86)
  
  • Widoczność nazw (86)
  • Wykorzystanie innych komponentów (86)
  • Słowo kluczowe static (87)
• Twój pierwszy program w Javie (89)
  
  • Kompilacja i uruchomienie (90)
• Komentarze oraz dokumentowanie kodu (91)
  
  • Dokumentacja w komentarzach (91)
  • Składnia (92)
  • Osadzony HTML (93)
  • Niektóre znaczniki dokumentacyjne (93)
  • Przykład dokumentowania kodu (96)
• Styl programowania (96)
  
• Podsumowanie (97)
  
• Ćwiczenia (97)

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

• Używanie operatorów Javy (99)
  
  • Kolejność (100)
  • Przypisanie (100)
  • Operatory matematyczne (103)
  • Operatory zwiększania i zmniejszania (106)
  • Operatory relacji (107)
  • Operatory logiczne (109)
  • Operatory bitowe (111)
  • Operatory przesunięcia (112)
  • Operator trójargumentowy if-else (115)
  • Przecinek (116)
  • Łańcuchowy operator + (116)
  • Najczęstsze pułapki przy używaniu operatorów (117)
  • Operatory rzutowania (117)
  • W Javie nie ma "sizeof" (120)
  • Powtórka z kolejności operatorów (120)
  • Kompendium operatorów (121)
• Sterowanie wykonaniem (129)
  
  • Prawda i fałsz (129)
  • if-else (129)
  • return (130)
  • Iteracja (131)
  • do-while (132)
  • for (132)
  • break i continue (134)
  • switch (139)
• Podsumowanie (143)
  
• Ćwiczenia (143)

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

• Gwarantowana inicjalizacja przez konstruktor (145)
  
• Przeciążanie metod (147)
  
  • Rozróżnianie przeciążonych metod (150)
  • Przeciążanie a typy podstawowe (150)
  • Przeciążanie przez wartości zwracane (155)
  • Konstruktory domyślne (155)
  • Słowo kluczowe this (156)
• Sprzątanie: finalizacja i odśmiecanie pamięci (159)
  
  • Do czego służy finalize() (160)
  • Musisz przeprowadzić sprzątanie (161)
  • Warunek zakończenia (162)
  • Jak działa odśmiecacz pamięci (163)
• Inicjalizacja składowych (166)
  
  • Określanie sposobu inicjalizacji (167)
  • Inicjalizacja w konstruktorze (168)
• Inicjalizacja tablic (174)
  
  • Tablice wielowymiarowe (179)
• Podsumowanie (182)
  
• Ćwiczenia (182)

Rozdział 5. Ukrywanie implementacji (185)

• Pakiet - jednostka biblioteczna (186)
  
  • Tworzenie unikatowych nazw pakietów (188)
  • Własna biblioteka narzędziowa (191)
  • Wykorzystanie instrukcji import do zmiany zachowania (192)
  • Pułapka związana z pakietami (192)
• Modyfikatory dostępu w Javie (192)
  
  • Dostęp pakietowy (193)
  • public: dostęp do interfejsu (194)
  • private: nie dotykać! (195)
  • protected: dostęp "na potrzeby" dziedziczenia (196)
• 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 (214)
  • Ukrywanie nazw (217)
• Wybór między kompozycją a dziedziczeniem (218)
  
• protected (220)
  
• Przyrostowe tworzenie oprogramowania (221)
  
• Rzutowanie w górę (222)
  
  • Dlaczego "w górę" (223)
• Słowo kluczowe final (224)
  
  • Zmienne finalne (224)
  • Metody finalne (227)
  • Klasy finalne (230)
  • Ostrożnie z deklaracją final (230)
• Inicjalizacja i ładowanie klas (231)
  
  • Inicjalizacja w przypadku dziedziczenia (232)
• Podsumowanie (233)
  
• Ćwiczenia (233)

Rozdział 7. Polimorfizm (237)

• Rzutowanie w górę raz jeszcze (237)
  
  • Zapominanie o typie obiektu (239)
• Mały trik (240)
  
  • Wiązanie wywołania metody (241)
  • Uzyskiwanie poprawnego działania (241)
  • Rozszerzalność (244)
  • Pułapka: "przesłanianie" metod prywatnych (246)
• Klasy i metody abstrakcyjne (247)
  
• Konstruktory a polimorfizm (250)
  
  • Kolejność wywołań konstruktorów (250)
  • Dziedziczenie a sprzątanie (252)
  • Zachowanie się metod polimorficznych wewnątrz konstruktorów (255)
• Projektowanie z użyciem dziedziczenia (257)
  
  • Czyste dziedziczenie kontra rozszerzanie (259)
  • Rzutowanie w dół a identyfikacja typu w czasie wykonania (260)
• Podsumowanie (262)
  
• Ćwiczenia (262)

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

• Interfejsy (265)
  
  • "Wielokrotne dziedziczenie" w Javie (268)
  • Rozszerzanie interfejsu poprzez dziedziczenie (271)
  • Grupowanie stałych (272)
  • Inicjalizacja pól interfejsów (274)
  • Zagnieżdżanie interfejsów (275)
• Klasy wewnętrzne (277)
  
  • Klasy wewnętrzne a rzutowanie w górę (279)
  • Klasy wewnętrzne w metodach i zasięgach (280)
  • Anonimowe klasy wewnętrzne (282)
  • Połączenie z klasą zewnętrzną (286)
  • Klasy zagnieżdżone (288)
  • Odwoływanie się do obiektu klasy zewnętrznej (290)
  • Sięganie na zewnątrz z klasy wielokrotnie zagnieżdżonej (290)
  • Dziedziczenie po klasach wewnętrznych (291)
  • Czy klasy wewnętrzne mogą być przesłaniane (292)
  • Lokalne klasy wewnętrzne (293)
  • Identyfikatory klas wewnętrznych (295)
• Dlaczego klasy wewnętrzne (296)
  
  • Domknięcia i wywołania zwrotne (298)
  • Klasy wewnętrzne a szkielety sterowania (300)
• Podsumowanie (306)
  
• Ćwiczenia (306)

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

• Podstawy obsługi wyjątków (310)
  
  • Parametry wyjątków (311)
• Przechwytywanie wyjątku (312)
  
  • Blok try (312)
  • Obsługa wyjątków (312)
• Tworzenie własnych wyjątków (314)
  
• Specyfikacja wyjątków (317)
  
• Przechwytywanie dowolnego wyjątku (318)
  
  • Ponowne wyrzucanie wyjątków (320)
  • Sekwencje wyjątków (323)
• Standardowe wyjątki Javy (326)
  
  • Specjalny przypadek RuntimeException (326)
• Robienie porządków w finally (328)
  
  • Do czego służy finally (329)
  • Pułapka: zagubiony wyjątek (331)
• Ograniczenia wyjątków (332)
  
• Konstruktory (335)
  
• Dopasowywanie wyjątków (338)
  
• Rozwiązania alternatywne (339)
  
  • Historia (341)
  • Perspektywy (342)
  • Przekazywanie wyjątków na konsolę (345)
  • Zamiana wyjątków sprawdzanych na niesprawdzane (345)
• Wskazówki (347)
  
• Podsumowanie (348)
  
• Ćwiczenia (348)

Rozdział 10. Wykrywanie typów (351)

• Potrzeba mechanizmu RTTI (351)
  
  • Obiekt Class (354)
  • Sprawdzanie przed rzutowaniem (356)
• Składnia RTTI (366)
  
• Refleksje - informacja o klasie w czasie wykonania (368)
  
  • Ekstraktor metod klasowych (369)
• Podsumowanie (373)
  
• Ćwiczenia (374)

Rozdział 11. Kolekcje obiektów (375)

• Tablice (375)
  
  • Tablice to obiekty (376)
  • Tablice jako wartości zwracane (379)
  • Klasa Arrays (381)
  • Wypełnianie tablicy (387)
  • Kopiowanie tablic (389)
  • Porównywanie tablic (390)
  • Porównywanie elementów tablic (391)
  • Sortowanie tablic (394)
  • Przeszukiwanie tablicy posortowanej (395)
  • Podsumowanie wiadomości o tablicach (397)
• Wprowadzenie do kontenerów (397)
  
  • Wypisanie zawartości kontenerów (398)
  • Wypełnianie kontenerów (400)
• Wada kontenera: nieznany typ (405)
  
  • Czasami mimo wszystko działa (407)
  • Tworzenie świadomej typu klasy ArrayList (408)
• Iteratory (410)
  
• Rodzaje kontenerów (413)
  
• Interfejs Collection (416)
  
• Interfejs List (418)
  
  • Stos na podstawie LinkedList (422)
  • Kolejka na podstawie LinkedList (423)
• Interfejs Set (423)
  
  • SortedSet (426)
• Możliwości funkcjonalne interfejsu Map (427)
  
  • SortedMap (431)
  • LinkedHashMap (433)
  • Haszowanie i kody haszujące (434)
  • Przesłonięcie metody hashCode() (443)
• Przechowywanie referencji (446)
  
  • WeakHashMap (449)
• Iteratory ponownie (450)
  
• Wybór implementacji (451)
  
  • Wybór między listami (452)
  • Wybór implementacji zbioru (454)
  • Wybór implementacji odwzorowania (456)
• Sortowanie i przeszukiwanie list (459)
  
• Dodatkowe usługi (460)
  
  • Niemodyfikowalne kontenery Collection i Map (462)
  • Synchronizacja Collection i Map (463)
• Nieobsługiwane operacje (464)
  
• Kontenery Java 1.0 i 1.1 (466)
  
  • Vector i Enumeration (467)
  • Hashtable (468)
  • Stack (468)
  • BitSet (469)
• Podsumowanie (470)
  
• Ćwiczenia (471)

Rozdział 12. System wejścia-wyjścia w Javie (477)

• Klasa File (477)
  
  • Wypisywanie zawartości katalogu (478)
  • Operacje na katalogach (481)
• Wejście i wyjście (483)
  
  • Typy InputStream (483)
  • Typy OutputStream (484)
• Dodawanie atrybutów i użytecznych interfejsów (485)
  
  • Czytanie z InputStream za pomocą FilterInputStream (486)
  • Zapis do OutputStream za pomocą FilterOutputStream (486)
• Klasy Reader i Writer (488)
  
  • Źródła i ujścia danych (489)
  • Modyfikacja zachowania strumienia (489)
  • Klasy niezmienione (490)
• Osobna i samodzielna RandomAccessFile (491)
  
• Typowe zastosowania strumieni I/O (491)
  
  • Strumienie wejścia (493)
  • Strumienie wyjścia (495)
  • Strumienie typu "pipe" (497)
• Narzędzia do zapisu i odczytu danych z plików (497)
  
• Standardowe wejście-wyjście (498)
  
  • Czytanie ze standardowego wejścia (499)
  • Zamiana System.out na PrintWriter (499)
  • Przekierowywanie standardowego wejścia-wyjścia (500)
• Nowe wejście-wyjście (501)
  
  • Konwersja danych (505)
  • Pobieranie podstawowych typów danych (508)
  • Widoki buforów (509)
  • Manipulowanie danymi przy użyciu buforów (514)
  • Szczegółowe informacje o buforach (515)
  • Pliki odwzorowywane w pamięci (518)
  • Blokowanie plików (521)
• Kompresja (524)
  
  • Prosta kompresja do formatu GZIP (524)
  • Przechowywanie wielu plików w formacie Zip (525)
  • Archiwa Javy (JAR) (528)
• Serializacja obiektów (529)
  
  • Odnajdywanie klasy (533)
  • Kontrola serializacji (534)
  • Stosowanie trwałości (542)
• Preferencje (547)
  
• Wyrażenia regularne (549)
  
  • Tworzenie wyrażeń regularnych (549)
  • Kwantyfikatory (551)
  • Klasy Pattern oraz Matcher (552)
  • metoda split() (559)
  • Operacje zastępowania (560)
  • Metoda reset() (562)
  • Wyrażenia regularne i operacje wejścia-wyjścia Javy (563)
  • Czy klasa StringTokenizer jest potrzebna (564)
• Podsumowanie (565)
  
• Ćwiczenia (565)

Rozdział 13. Współbieżność (569)

• Motywacja (570)
  
• Proste wątki (571)
  
  • Przełączanie (573)
  • Wstrzymywanie wykonywania wątku (574)
  • Priorytet (576)
  • Wątki demony (578)
  • Łączenie wątków (580)
  • Różne sposoby kodowania (582)
  • Tworzenie wrażliwego interfejsu użytkownika (587)
• Współdzielenie ograniczonych zasobów (588)
  
  • Niewłaściwy dostęp do zasobów (589)
  • Kolizje podczas dostępu do zasobów (593)
  • Rozwiązywanie współzawodnictwa o zasoby współdzielone (595)
  • Sekcje krytyczne (601)
• Stany wątków (606)
  
  • Zablokowanie (606)
• Współdziałanie wątków (607)
  
  • Wait i notify (607)
  • Stosowanie potoków do przekazywania danych pomiędzy wątkami (611)
  • Bardziej wyszukane sposoby współdziałania (612)
• Wzajemna blokada (612)
  
• Poprawny sposób zatrzymywania (617)
  
• Przerywanie zablokowanego wątku (618)
  
• Grupy wątków (619)
  
• Podsumowanie (619)
  
• Ćwiczenia (621)

Rozdział 14. Tworzenie okienek i apletów (623)

• Podstawy tworzenia apletów (625)
  
  • Ograniczenia apletów (625)
  • Zalety apletów (626)
  • Szkielet aplikacji (627)
  • Uruchamianie apletów w przeglądarce internetowej (628)
  • Wykorzystanie programu Appletviewer (629)
  • Testowanie apletów (630)
• Uruchamianie apletów z wiersza poleceń (631)
  
  • Platforma prezentacyjna (632)
• Tworzenie przycisku (634)
  
• Przechwytywanie zdarzenia (635)
  
• Pola tekstowe (637)
  
• Rozmieszczenie komponentów (639)
  
  • BorderLayout (639)
  • FlowLayout (640)
  • GridLayout (641)
  • GridBagLayout (642)
  • Bezpośrednie pozycjonowanie (642)
  • BoxLayout (642)
  • Najlepsze rozwiązanie? (645)
• Model zdarzeń w Swingu (646)
  
  • Rodzaje zdarzeń i odbiorców (646)
  • Śledzenie wielu zdarzeń (652)
• Katalog komponentów Swing (654)
  
  • Przyciski (655)
  • Ikony (657)
  • Podpowiedzi (659)
  • Pola tekstowe (659)
  • Ramki (661)
  • Panele z paskami przewijania (662)
  • Miniedytor (663)
  • Pola wyboru (664)
  • Przyciski wyboru (666)
  • Listy rozwijane (667)
  • Listy (668)
  • Zakładki (670)
  • Okna komunikatów (671)
  • Menu (672)
  • Menu kontekstowe (677)
  • Rysowanie (679)
  • Okna dialogowe (681)
  • Okna dialogowe plików (685)
  • HTML w komponentach Swing (686)
  • Suwaki i paski postępu (687)
  • Drzewa (688)
  • Tabele (690)
  • Zmiana wyglądu aplikacji (692)
  • Schowek (694)
• Pakowanie apletu do pliku JAR (696)
  
• Cyfrowe podpisywanie apletów (697)
  
• JNLP oraz Java Web Start (701)
  
• Techniki programowania (706)
  
  • Dynamiczne dołączanie zdarzeń (706)
  • Oddzielenie logiki biznesowej od interfejsu użytkownika (708)
  • Postać kanoniczna (710)
• Współbieżność i Swing (710)
  
  • Interfejs Runnable raz jeszcze (711)
  • Zarządzanie współbieżnością (713)
• Programowanie wizualne i Beany (716)
  
  • Czym jest Bean (717)
  • Wydobycie informacji o Beanie poprzez introspektor (719)
  • Bardziej wyszukany Bean (724)
  • Beany i synchronizacja (727)
  • Pakowanie Beana (730)
  • Bardziej złożona obsługa Beanów (732)
  • Więcej o Beanach (732)
• Podsumowanie (733)
  
• Ćwiczenia (734)

Rozdział 15. Wykrywanie problemów (737)

• Testowanie modułów (739)
  
  • Prosty szkielet testowy (741)
  • JUnit (750)
• Poprawianie niezawodności poprzez wykorzystanie asercji (754)
  
  • Składnia asercji (755)
  • Użycie asercji do projektowania przez kontrakt (758)
  • Przykład: projektowanie przez kontrakt i testowanie modułów metodą "białej skrzynki" (761)
• Konstruowanie przy użyciu narzędzia Ant (765)
  
  • Zautomatyzujmy wszystko (766)
  • Problemy z make (766)
  • Ant: faktyczny standard (767)
  • Kontrola wersji przy użyciu CVS (771)
  • Prace codzienne (774)
• Rejestracja (775)
  
  • Poziomy rejestracji (776)
  • LogRecord (779)
  • Handler (780)
  • Filtry (784)
  • Formatter (785)
  • Przykład: rejestracja informacji poprzez wysyłanie wiadomości pocztą elektroniczną (787)
  • Kontrola poziomu rejestracji przez wykorzystanie przestrzeni nazw (789)
  • Praktyki rejestracyjne stosowane w dużych projektach (791)
  • Podsumowanie (793)
• Testowanie (794)
  
  • Testowanie przy wykorzystaniu JDB (794)
  • Graficzne programy uruchomieniowe (799)
• Profilowanie i optymalizacja (799)
  
  • Śledzenie zużycia pamięci (800)
  • Śledzenie wykorzystania procesora (800)
  • Testowanie obłożenia (800)
  • Interfejs profilujący JVM (801)
  • Wykorzystanie HPROF (801)
  • Efektywność działania wątków (803)
  • Wytyczne optymalizacji (804)
• Doclety (804)
  
• Podsumowanie (806)
  
• Ćwiczenia (808)

Rozdział 16. Analiza i projekt (811)

• Metodologia (811)
  
• Faza 0.: stwórz plan (813)
  
  • Określenie celu (814)
• Faza 1.: co robimy (814)
  
• Faza 2.: jak to stworzymy (817)
  
  • Pięć etapów projektowania obiektów (819)
  • Wytyczne dotyczące tworzenia obiektów (820)
• Faza 3.: tworzenie jądra systemu (821)
  
• Faza 4.: przejrzenie przypadków użycia (821)
  
• Faza 5.: ewolucja (822)
  
• Opłaca się planować (824)
  
• Programowanie ekstremalne (824)
  
  • Najpierw pisz testy (825)
  • Programowanie w parach (826)
• Strategie przejścia (827)
  
  • Wytyczne (827)
  • Przeszkody w zarządzaniu (829)
• Podsumowanie (830)

Dodatek A Przekazywanie i zwracanie obiektów (831)

• Przekazywanie referencji (831)
  
  • Aliasy (832)
• Tworzenie kopii lokalnych (834)
  
  • Przekazywanie przez wartość (834)
  • Klonowanie obiektów (835)
  • Dodanie klonowalności do klasy (836)
  • Udane klonowanie (838)
  • Działanie Object.clone() (840)
  • Klonowanie złożonego obiektu (842)
  • Głęboka kopia ArrayList (844)
  • Głęboka kopia poprzez serializację (845)
  • Dodanie klonowalności w dół hierarchii (847)
  • Dlaczego takie dziwne rozwiązanie (848)
• Sterowanie klonowalnością (848)
  
  • Konstruktor kopiujący (853)
• Klasy tylko do odczytu (857)
  
  • Tworzenie klas tylko do odczytu (858)
  • Wada obiektów odpornych na zmiany (859)
  • Niezmienne obiekty String (861)
  • Klasy String i StringBuffer (864)
  • Łańcuchy są wyjątkowe (866)
• Podsumowanie (867)
  
• Ćwiczenia (868)

Dodatek B Wskazówki dla programistów (869)

• Projekt (869)
  
• Implementacja (874)

Dodatek C Materiały uzupełniające (879)

• Szkolenie "Thinking in Java" (879)
  
• Szkolenie na CD-ROM-ie "Hands-On Java 3rd edition" (879)
  
• Szkolenie "Designing Object & Systems" (880)
  
• Thinking in Enterprise Java (880)
  
• Szkolenie J2EE (881)
  
• Thinking in Patterns (with Java) (881)
  
• Szkolenie "Thinking in Patterns" (882)
  
• Konsultacja i analiza projektów (882)

Dodatek D Zasoby (883)

• Oprogramowanie (883)
  
• Książki (883)
  
  • Analiza i projektowanie (884)
  • Python (886)
  • Lista moich książek (887)

Skorowidz (889)