Zacznij tworzyć niezależne od platformy aplikacje jeszcze dziś!

• Jakie nowości kryją się w Java Standard Edition 6?
• Jak rozpocząć przygodę z językiem Java?
• Jak wykorzystać wielowątkowość?

• Podstawy języka Java
- Programowanie obiektowe- Interfejsy- Sposób użycia klas proxy oraz klas wewnętrznych- Projektowanie interfejsu użytkownika z wykorzystaniem biblioteki Swing- Obsługa wyjątków- Wykrywanie i rozwiązywanie problemów w kodzie - Wielowątkowość

Spis treści:

• Java jako platforma programistyczna (21)
  
• Słowa klucze białej księgi Javy (22)
  
  • Prosty (23)
  • Zorientowany obiektowo (23)
  • Sieciowy (24)
  • Niezawodny (24)
  • Bezpieczny (25)
  • Niezależny od architektury (26)
  • Przenośny (26)
  • Interpretowany (27)
  • Wysokowydajny (27)
  • Wielowątkowy (27)
  • Dynamiczny (28)
• Aplety Javy i internet (28)
  
• Krótka historia Javy (30)
  
• Główne nieporozumienia dotyczące Javy (32)

• Instalacja oprogramowania Java Development Kit (38)
  
  • Pobieranie pakietu JDK (38)
  • Ustawianie ścieżki dostępu (40)
  • Instalacja bibliotek i dokumentacji (41)
  • Instalacja przykładowych programów (42)
  • Drzewo katalogów Javy (43)
• Wybór środowiska programistycznego (44)
  
• Używanie narzędzi wiersza poleceń (44)
  
  • Rozwiązywanie problemów (46)
• Praca w zintegrowanym środowisku programistycznym (47)
  
  • Znajdowanie błędów kompilacji (50)
• Uruchamianie aplikacji graficznej (51)
  
• Tworzenie i uruchamianie apletów (53)

• Prosty program w Javie (60)
  
• Komentarze (63)
  
• Typy danych (64)
  
  • Typy całkowite (64)
  • Typy zmiennoprzecinkowe (65)
  • Typ char (66)
  • Typ boolean (68)
• Zmienne (69)
  
  • Inicjacja zmiennych (70)
  • Stałe (70)
• Operatory (71)
  
  • Operatory inkrementacji i dekrementacji (72)
  • Operatory relacyjne i logiczne (73)
  • Operatory bitowe (74)
  • Funkcje i stałe matematyczne (75)
  • Konwersja typów numerycznych (76)
  • Rzutowanie (77)
  • Nawiasy i priorytety operatorów (78)
  • Typ wyliczeniowy (79)
• Łańcuchy (79)
  
  • Podłańcuchy (79)
  • Konkatenacja (80)
  • Łańcuchów nie można modyfikować (80)
  • Porównywanie łańcuchów (82)
  • Współrzędne kodowe znaków i jednostki kodowe (83)
  • API String (84)
  • Dokumentacja API w internecie (86)
  • Składanie łańcuchów (87)
• Wejście i wyjście (90)
  
  • Odbieranie danych wejściowych (90)
  • Formatowanie danych wyjściowych (93)
  • Zapis do pliku i odczyt (97)
• Przepływ sterowania (99)
  
  • Zasięg blokowy (99)
  • Instrukcje warunkowe (100)
  • Pętle (102)
  • Pętle o określonej liczbie powtórzeń (107)
  • Wybór wielokierunkowy - instrukcja switch (110)
  • Instrukcje przerywające przepływ sterowania (112)
• Wielkie liczby (115)
  
• Tablice (118)
  
  • Pętla typu for each (119)
  • Inicjowanie tablic i tworzenie tablic anonimowych (120)
  • Kopiowanie tablicy (120)
  • Parametry wiersza poleceń (122)
  • Sortowanie tablicy (123)
  • Tablice wielowymiarowe (127)
  • Tablice postrzępione (130)

• Wstęp do programowania zorientowanego obiektowo (134)
  
  • Klasy (134)
  • Obiekty (136)
  • Identyfikacja klas (136)
  • Relacje między klasami (137)
• Używanie klas predefiniowanych (139)
  
  • Obiekty i zmienne obiektów (139)
  • Klasa GregorianCalendar (142)
  • Metody udostępniające i zmieniające wartość elementu (144)
• Definiowanie własnych klas (150)
  
  • Klasa Employee (151)
  • Stosowanie kilku plików źródłowych (154)
  • Analiza klasy Employee (154)
  • Pierwsze kroki w tworzeniu konstruktorów (155)
  • Parametry jawne i niejawne (156)
  • Korzyści z hermetyzacji (157)
  • Przywileje klasowe (159)
  • Metody prywatne (160)
  • Stałe jako pola klasy (161)
• Pola i metody statyczne (161)
  
  • Pola statyczne (161)
  • Stałe statyczne (162)
  • Metody statyczne (163)
  • Metody fabrykujące (164)
  • Metoda main (165)
• Parametry metod (167)
  
• Konstruowanie obiektów (173)
  
  • Przeciążanie (173)
  • Inicjacja pól wartościami domyślnymi (174)
  • Konstruktor domyślny (175)
  • Jawna inicjacja pól (175)
  • Nazywanie parametrów (176)
  • Wywoływanie innego konstruktora (177)
  • Bloki inicjujące (178)
  • Niszczenie obiektów i metoda finalize (182)
• Pakiety (182)
  
  • Importowanie klas (183)
  • Importy statyczne (185)
  • Dodawanie klasy do pakietu (185)
  • Zasięg pakietów (188)
• Ścieżka klas (190)
  
  • Ustawianie ścieżki klas (192)
• Komentarze dokumentacyjne (193)
  
  • Wstawianie komentarzy (193)
  • Komentarze do klas (194)
  • Komentarze do metod (194)
  • Komentarze do pól (195)
  • Komentarze ogólne (195)
  • Komentarze do pakietów i ogólne (197)
  • Generowanie dokumentacji (197)
• Porady dotyczące projektowania klas (198)

• Klasy, nadklasy i podklasy (202)
  
  • Hierarchia dziedziczenia (208)
  • Polimorfizm (208)
  • Wiązanie dynamiczne (210)
  • Wyłączanie dziedziczenia - klasy i metody finalne (213)
  • Rzutowanie (214)
  • Klasy abstrakcyjne (216)
  • Dostęp chroniony (221)
• Klasa bazowa Object (222)
  
  • Metoda equals (223)
  • Porównywanie a dziedziczenie (224)
  • Metoda hashCode (227)
  • Metoda toString (229)
• Generyczne listy tablicowe (234)
  
  • Dostęp do elementów listy tablicowej (237)
  • Zgodność pomiędzy typowanymi a surowymi listami tablicowymi (241)
• Osłony obiektów i autoboxing (242)
  
• Metody ze zmienną liczbą parametrów (245)
  
• Klasy wyliczeniowe (246)
  
• Refleksja (248)
  
  • Klasa Class (249)
  • Podstawy przechwytywania wyjątków (251)
  • Zastosowanie refleksji w analizie funkcjonalności klasy (253)
  • Refleksja w analizie obiektów w czasie działania programu (258)
  • Zastosowanie refleksji w generycznym kodzie tablicowym (263)
  • Wskaźniki do metod (267)
• Porady projektowe dotyczące dziedziczenia (270)

• Interfejsy (274)
  
  • Własności interfejsów (279)
  • Interfejsy a klasy abstrakcyjne (280)
• Klonowanie obiektów (281)
  
• Interfejsy a sprzężenie zwrotne (287)
  
• Klasy wewnętrzne (290)
  
  • Dostęp do stanu obiektu w klasie wewnętrznej (292)
  • Specjalne reguły składniowe dotyczące klas wewnętrznych (295)
  • Czy klasy wewnętrzne są potrzebne i bezpieczne? (296)
  • Lokalne klasy wewnętrzne (298)
  • Dostęp do zmiennych finalnych z metod zewnętrznych (299)
  • Anonimowe klasy wewnętrzne (301)
  • Statyczne klasy wewnętrzne (304)
• Klasy proxy (307)
  
  • Własności klas proxy (311)

• Wprowadzenie do pakietu Swing (314)
  
• Tworzenie ramki (317)
  
• Pozycjonowanie ramki (320)
  
  • Własności ramek (322)
  • Określanie rozmiaru ramki (323)
• Wyświetlanie informacji w komponencie (327)
  
• Figury 2W (331)
  
• Kolory (339)
  
• Czcionki (343)
  
• Wyświetlanie obrazów (351)

• Podstawy obsługi zdarzeń (355)
  
  • Przykład - obsługa kliknięcia przycisku (357)
  • Nabywanie biegłości w posługiwaniu się klasami wewnętrznymi (362)
  • Tworzenie słuchaczy zawierających jedno wywołanie metody (365)
  • Przykład - zmiana stylu (366)
  • Klasy adaptacyjne (370)
• Akcje (374)
  
• Zdarzenia generowane przez mysz (381)
  
• Hierarchia zdarzeń w bibliotece AWT (388)
  
  • Zdarzenia semantyczne i niskiego poziomu (390)

• Swing a wzorzec projektowy Model-View-Controller (394)
  
  • Wzorce projektowe (394)
  • Wzorzec Model-View-Controller (395)
  • Analiza MVC przycisków Swing (399)
• Wprowadzenie do zarządzania rozkładem (400)
  
  • Rozkład brzegowy (403)
  • Rozkład siatkowy (405)
• Wprowadzanie tekstu (409)
  
  • Pola tekstowe (409)
  • Etykiety komponentów (411)
  • Pola haseł (413)
  • Obszary tekstowe (413)
  • Panele przewijane (414)
• Komponenty umożliwiające wybór opcji (417)
  
  • Pola wyboru (417)
  • Przełączniki (420)
  • Obramowanie (424)
  • Listy rozwijalne (428)
  • Suwaki (432)
• Menu (438)
  
  • Tworzenie menu (439)
  • Ikony w elementach menu (441)
  • Pola wyboru i przełączniki jako elementy menu (442)
  • Menu podręczne (444)
  • Mnemoniki i akceleratory (445)
  • Aktywowanie i dezaktywowanie elementów menu (448)
  • Paski narzędzi (451)
  • Dymki (453)
• Zaawansowane techniki zarządzania rozkładem (456)
  
  • Rozkład GridBagLayout (458)
  • Rozkład grupowy (468)
  • Nieużywanie żadnego zarządcy rozkładu (478)
  • Niestandardowi zarządcy rozkładu (479)
  • Kolejka dostępu (483)
• Okna dialogowe (485)
  
  • Okna dialogowe opcji (485)
  • Tworzenie okien dialogowych (495)
  • Wymiana danych (500)
  • Okna dialogowe wyboru plików (506)
  • Okna dialogowe wyboru kolorów (517)

• Pliki JAR (526)
  
  • Manifest (526)
  • Wykonywalne pliki JAR (528)
  • Zasoby (529)
  • Pieczętowanie pakietów (532)
• Java Web Start (533)
  
  • Sandbox (537)
  • Podpisywanie kodu (538)
  • API JNLP (539)
• Aplety (548)
  
  • Prosty aplet (549)
  • Znacznik applet i jego atrybuty (553)
  • Znacznik object (557)
  • Parametry przekazujące informacje do apletów (557)
  • Dostęp do obrazów i plików audio (562)
  • Środowisko działania apletu (563)
• Zapisywanie preferencji użytkownika (572)
  
  • Mapy własności (572)
  • API Preferences (577)

• Obsługa błędów (586)
  
  • Klasyfikacja wyjątków (587)
  • Deklarowanie wyjątków kontrolowanych (589)
  • Zgłaszanie wyjątków (591)
  • Tworzenie klas wyjątków (593)
• Przechwytywanie wyjątków (594)
  
  • Przechwytywanie wielu typów wyjątków (596)
  • Powtórne generowanie wyjątków i budowanie łańcuchów wyjątków (596)
  • Klauzula finally (597)
  • Analiza danych ze śledzenia stosu (601)
• Wskazówki dotyczące stosowania wyjątków (604)
  
• Asercje (607)
  
  • Włączanie i wyłączanie asercji (608)
  • Zastosowanie asercji w sprawdzaniu parametrów (608)
  • Zastosowanie asercji w dokumentacji założeń (610)
• Dzienniki (611)
  
  • Podstawy zapisu do dziennika (611)
  • Zaawansowane techniki zapisu do dziennika (612)
  • Zmiana konfiguracji menedżera dzienników (614)
  • Lokalizacja (615)
  • Obiekty typu Handler (616)
  • Filtry (620)
  • Formatery (620)
  • Przepis na dziennik (620)
• Wskazówki dotyczące debugowania (629)
  
  • Używanie okna konsoli (635)
  • Śledzenie zdarzeń AWT (636)
  • Zaprzęganie robota AWT do pracy (640)
• Praca z debugerem (645)

• Dlaczego programowanie uogólnione (650)
  
  • Dla kogo programowanie uogólnione (651)
• Definicja prostej klasy uogólnionej (652)
  
• Metody uogólnione (654)
  
• Ograniczenia zmiennych typowych (655)
  
• Kod uogólniony a maszyna wirtualna (657)
  
  • Translacja wyrażeń generycznych (659)
  • Translacja metod uogólnionych (660)
  • Używanie starego kodu (662)
• Ograniczenia i braki (663)
  
  • Nie można podawać typów prostych jako parametrów typowych (663)
  • Sprawdzanie typów w czasie działania programu jest możliwe tylko dla typów surowych (663)
  • Obiektów klasy uogólnionej nie można generować ani przechwytywać (664)
  • Nie można tworzyć tablic typów uogólnionych (665)
  • Nie wolno tworzyć egzemplarzy zmiennych typowych (665)
  • Zmiennych typowych nie można używać w statycznych kontekstach klas uogólnionych (667)
  • Uważaj na konflikty, które mogą powstać po wymazaniu typów (667)
• Zasady dziedziczenia dla typów uogólnionych (668)
  
• Typy wieloznaczne (671)
  
  • Ograniczenia nadtypów typów wieloznacznych (672)
  • Typy wieloznaczne bez ograniczeń (674)
  • Chwytanie typu wieloznacznego (675)
• Refleksja a typy uogólnione (679)
  
  • Zastosowanie parametrów Class do dopasowywania typów (680)
  • Informacje o typach generycznych w maszynie wirtualnej (680)

• Interfejsy kolekcyjne (687)
  
  • Oddzielenie warstwy interfejsów od warstwy klas konkretnych (688)
  • Interfejsy Collection i Iterator (690)
• Konkretne klasy kolekcyjne (696)
  
  • Listy powiązane (696)
  • Listy tablicowe (706)
  • Zbiór HashSet (706)
  • Zbiór TreeSet (710)
  • Porównywanie obiektów (711)
  • Kolejki Queue i Deque (717)
  • Kolejki priorytetowe (718)
  • Mapy (719)
  • Specjalne klasy Set i Map (724)
• Architektura kolekcji (729)
  
  • Widoki i obiekty opakowujące (733)
  • Operacje zbiorcze (739)
  • Konwersja pomiędzy kolekcjami a tablicami (740)
• Algorytmy (741)
  
  • Sortowanie i tasowanie (742)
  • Wyszukiwanie binarne (745)
  • Proste algorytmy (746)
  • Pisanie własnych algorytmów (748)
• Stare kolekcje (749)
  
  • Klasa Hashtable (749)
  • Wyliczenia (750)
  • Mapy własności (751)
  • Stosy (751)
  • Zbiory bitów (752)

• Czym są wątki (758)
  
  • Wykonywanie zadań w osobnych wątkach (763)
• Przerywanie wątków (769)
  
• Stany wątków (771)
  
  • Wątki NEW (772)
  • Wątki RUNNABLE (772)
  • Wątki BLOCKED i WAITING (773)
  • Zamykanie wątków (773)
• Własności wątków (775)
  
  • Priorytety wątków (775)
  • Wątki demony (776)
  • Procedury obsługi nieprzechwyconych wyjątków (777)
• Synchronizacja (778)
  
  • Przykład sytuacji powodującej wyścig (778)
  • Wyścigi (783)
  • Obiekty klasy Lock (784)
  • Warunki (787)
  • Słowo kluczowe synchronized (792)
  • Bloki synchronizowane (796)
  • Monitor (797)
  • Pola ulotne (798)
  • Zakleszczenia (800)
  • Testowanie blokad i odmierzanie czasu (803)
  • Blokady odczytu-zapisu (804)
  • Dlaczego metody stop i suspend są odradzane (805)
• Kolejki blokujące (808)
  
• Kolekcje bezpieczne wątkowo (815)
  
  • Szybkie mapy, zbiory i kolejki (815)
  • Tablice kopiowane przy zapisie (817)
  • Starsze kolekcje bezpieczne wątkowo (817)
• Interfejsy Callable i Future (819)
  
• Klasa Executors (823)
  
  • Pule wątków (824)
  • Planowanie wykonywania (828)
  • Kontrolowanie grup zadań (829)
• Synchronizatory (830)
  
  • Semafory (830)
  • Klasa CountDownLatch (831)
  • Bariery (832)
  • Klasa Exchanger (833)
  • Kolejki synchroniczne (833)
  • Przykład - wstrzymywanie i ponowne uruchamianie animacji (833)
• Wątki a biblioteka Swing (839)
  
  • Uruchamianie czasochłonnych zadań (840)
  • Klasa SwingWorker (845)
  • Zasada jednego wątku (851)