Java. Kompendium programisty. Wydanie IX

 
Java. Kompendium programisty. Wydanie IX
Zawiera darmowych rozdziałów: 29
Stron w książce: 1136 Udostępniono darmowych stron: 31
Data wydania: 2015-09-10Przejdź na stronę księgarni
Czytano online: 10Cena książki drukowanej: 179,00 zł
Język wydania: PolishWydawnictwo: Helion
Pobierz pdfCzytaj Alt+1Czytaj online
( Alt+1 )

Kompletne źródło informacji na temat języka Java!

Od czasu swojej premiery w 1995 roku Java cieszy się niesłabnącą popularnością wśród programistów oraz pracodawców. Język ten znajduje zastosowanie wszędzie tam, gdzie wymagane są najwyższa wydajność, niezawodność i bezpieczeństwo. Ponadto każda kolejna wersja Javy wprowadza nowości, które sprawiają, że życie programisty staje się łatwiejsze, a tworzony kod bardziej przejrzysty.

Ukazanie się na rynku wersji ósmej tego języka jest świetną okazją do zapoznania się z najnowszym wydaniem cenionego podręcznika na jego temat, poprawionego oraz uzupełnionego o wiadomości o wprowadzonych nowościach. W trakcie lektury zdobędziesz informacje na temat składni Javy, typowych konstrukcji oraz najlepszych technik programowania. Ponadto poznasz platformę JavaFX i wyrażenia lambda oraz odkryjesz sposoby radzenia sobie z zagadnieniem wielowątkowości. Książka ta jest doskonałą i pasjonującą lekturą zarówno dla programistów języka Java, jak i osób chcących poznać ten język.

Dzięki tej książce:

  • poznasz składnię języka Java
  • zaznajomisz się z nowościami w Javie 8
  • wykorzystasz potencjał platformy JavaFX
  • opanujesz wyrażenia lambda
  • nauczysz się tworzyć wydajne rozwiązania wielowątkowe

Herbert Schildt – były członek komitetu ANSI/ISO, który dokonał standaryzacji języka C++. Autor popularnych publikacji poświęconych programowaniu, głównie w językach C, C++, C# i Java. Jego książki, wykorzystywane przez profesjonalistów, szkoleniowców i studentów, rozeszły się w ponad 3 milionach egzemplarzy.

...

O autorze (23)

Przedmowa (25)

CZĘŚĆ I. JĘZYK JAVA

1. Historia i ewolucja języka Java (31)

  • Rodowód Javy (31)
    • Narodziny nowoczesnego języka - C (31)
    • Język C++ - następny krok (33)
    • Podwaliny języka Java (33)
  • Powstanie języka Java (33)
    • Powiązanie z językiem C# (35)
  • Jak język Java zmienił internet (35)
    • Aplety Javy (35)
    • Bezpieczeństwo (36)
    • Przenośność (36)
  • Magia języka Java - kod bajtowy (36)
  • Serwlety - Java po stronie serwera (37)
  • Hasła języka Java (38)
    • Prostota (38)
    • Obiektowość (38)
    • Niezawodność (38)
    • Wielowątkowość (39)
    • Neutralność architektury (39)
    • Interpretowalność i wysoka wydajność (39)
    • Rozproszenie (39)
    • Dynamika (40)
  • Ewolucja Javy (40)
    • Java SE 8 (42)
  • Kultura innowacji (43)

2. Podstawy języka Java (45)

  • Programowanie obiektowe (45)
    • Dwa paradygmaty (45)
    • Abstrakcja (46)
    • Trzy zasady programowania obiektowego (46)
  • Pierwszy przykładowy program (50)
    • Wpisanie kodu programu (50)
    • Kompilacja programów (51)
    • Bliższe spojrzenie na pierwszy przykładowy program (51)
  • Drugi prosty program (53)
  • Dwie instrukcje sterujące (54)
    • Instrukcja if (54)
    • Pętla for (55)
  • Bloki kodu (56)
  • Kwestie składniowe (58)
    • Znaki białe (58)
    • Identyfikatory (58)
    • Stałe (58)
    • Komentarze (58)
    • Separatory (59)
    • Słowa kluczowe języka Java (59)
  • Biblioteki klas Javy (60)

3. Typy danych, zmienne i tablice (61)

  • Java to język ze ścisłą kontrolą typów (61)
  • Typy proste (61)
  • Typy całkowitoliczbowe (62)
    • Typ byte (62)
    • Typ short (63)
    • Typ int (63)
    • Typ long (63)
  • Typy zmiennoprzecinkowe (63)
    • Typ float (64)
    • Typ double (64)
  • Typ znakowy (64)
  • Typ logiczny (66)
  • Bliższe spojrzenie na stałe (66)
    • Stałe całkowitoliczbowe (66)
    • Stałe zmiennoprzecinkowe (67)
    • Stałe logiczne (68)
    • Stałe znakowe (68)
    • Stałe łańcuchowe (69)
  • Zmienne (69)
    • Deklaracja zmiennej (69)
    • Inicjalizacja dynamiczna (70)
    • Zasięg i czas życia zmiennych (70)
  • Konwersja typów i rzutowanie (72)
    • Automatyczna konwersja typów (72)
    • Rzutowanie niezgodnych typów (73)
  • Automatyczne rozszerzanie typów w wyrażeniach (74)
    • Zasady rozszerzania typu (74)
  • Tablice (75)
    • Tablice jednowymiarowe (75)
    • Tablice wielowymiarowe (77)
    • Alternatywna składnia deklaracji tablicy (80)
  • Kilka słów o łańcuchach (80)
  • Uwaga dla programistów języka C lub C++ na temat wskaźników (81)

4. Operatory (83)

  • Operatory arytmetyczne (83)
    • Podstawowe operatory arytmetyczne (84)
    • Operator reszty z dzielenia (84)
    • Operatory arytmetyczne z przypisaniem (85)
    • Inkrementacja i dekrementacja (86)
  • Operatory bitowe (87)
    • Logiczne operatory bitowe (88)
    • Przesunięcie w lewo (90)
    • Przesunięcie w prawo (91)
    • Przesunięcie w prawo bez znaku (92)
    • Operatory bitowe z przypisaniem (93)
  • Operatory relacji (94)
  • Operatory logiczne (95)
    • Operatory logiczne ze skracaniem (96)
  • Operator przypisania (96)
  • Operator ? (97)
  • Kolejność wykonywania operatorów (97)
  • Stosowanie nawiasów okrągłych (98)

5. Instrukcje sterujące (99)

  • Instrukcje wyboru (99)
    • Instrukcja if (99)
    • Instrukcja switch (102)
  • Instrukcje iteracyjne (105)
    • Pętla while (106)
    • Pętla do-while (107)
    • Pętla for (109)
    • Wersja for-each pętli for (112)
    • Pętle zagnieżdżone (116)
  • Instrukcje skoku (116)
    • Instrukcja break (117)
    • Instrukcja continue (120)
    • Instrukcja return (121)

6. Wprowadzenie do klas (123)

  • Klasy (123)
    • Ogólna postać klasy (123)
    • Prosta klasa (124)
  • Deklarowanie obiektów (126)
    • Bliższe spojrzenie na operator new (127)
  • Przypisywanie zmiennych referencyjnych do obiektów (127)
  • Wprowadzenie do metod (128)
    • Dodanie metody do klasy Box (129)
    • Zwracanie wartości (130)
    • Dodanie metody przyjmującej parametry (131)
  • Konstruktor (133)
    • Konstruktor sparametryzowany (134)
  • Słowo kluczowe this (135)
    • Ukrywanie zmiennych składowych (135)
  • Mechanizm odzyskiwania pamięci (136)
  • Metoda finalize() (136)
  • Klasa stosu (137)

7. Dokładniejsze omówienie metod i klas (139)

  • Przeciążanie metod (139)
    • Przeciążanie konstruktorów (141)
  • Obiekty jako parametry (143)
  • Dokładniejsze omówienie przekazywania argumentów (145)
  • Zwracanie obiektów (146)
  • Rekurencja (147)
  • Wprowadzenie do kontroli dostępu (149)
  • Składowe statyczne (152)
  • Słowo kluczowe final (153)
  • Powtórka z tablic (154)
  • Klasy zagnieżdżone i klasy wewnętrzne (155)
  • Omówienie klasy String (157)
  • Wykorzystanie argumentów wiersza poleceń (159)
  • Zmienna liczba argumentów (160)
    • Przeciążanie metod o zmiennej liczbie argumentów (162)
    • Zmienna liczba argumentów i niejednoznaczności (163)

8. Dziedziczenie (165)

  • Podstawy dziedziczenia (165)
    • Dostęp do składowych a dziedziczenie (166)
    • Bardziej praktyczny przykład (167)
    • Zmienna klasy bazowej może zawierać referencję do obiektu podklasy (169)
  • Słowo kluczowe super (170)
    • Wykorzystanie słowa kluczowego super do wywołania konstruktora klasy bazowej (170)
    • Drugie zastosowanie słowa kluczowego super (173)
  • Tworzenie hierarchii wielopoziomowej (173)
  • Kiedy są wykonywane konstruktory? (176)
  • Przesłanianie metod (177)
  • Dynamiczne przydzielanie metod (178)
    • Dlaczego warto przesłaniać metody? (180)
    • Zastosowanie przesłaniania metod (180)
  • Klasy abstrakcyjne (181)
  • Słowo kluczowe final i dziedziczenie (184)
    • Słowo kluczowe final zapobiega przesłanianiu (184)
    • Słowo kluczowe final zapobiega dziedziczeniu (184)
  • Klasa Object (185)

9. Pakiety i interfejsy (187)

  • Pakiety (187)
    • Definiowanie pakietu (187)
    • Znajdowanie pakietów i ścieżka CLASSPATH (188)
    • Prosty przykład pakietu (189)
  • Ochrona dostępu (189)
    • Przykład dostępu (190)
  • Import pakietów (192)
  • Interfejsy (194)
    • Definiowanie interfejsu (194)
    • Implementacja interfejsu (195)
    • Interfejsy zagnieżdżone (197)
    • Stosowanie interfejsów (198)
    • Zmienne w interfejsach (201)
    • Interfejsy można rozszerzać (202)
  • Metody domyślne (203)
    • Podstawy metod domyślnych (204)
    • Bardziej praktyczny przykład (205)
    • Problemy wielokrotnego dziedziczenia (206)
  • Metody statyczne w interfejsach (207)
  • Ostatnie uwagi dotyczące pakietów i interfejsów (207)

10. Obsługa wyjątków (209)

  • Podstawy obsługi wyjątków (209)
  • Typy wyjątków (210)
  • Nieprzechwycone wyjątki (210)
  • Stosowanie instrukcji try i catch (211)
    • Wyświetlenie opisu wyjątku (212)
  • Wiele klauzul catch (213)
  • Zagnieżdżone instrukcje try (214)
  • Instrukcja throw (216)
  • Klauzula throws (217)
  • Słowo kluczowe finally (217)
  • Wyjątki wbudowane w język Java (219)
  • Tworzenie własnej podklasy wyjątków (219)
  • Łańcuch wyjątków (222)
  • Trzy nowe cechy wyjątków (223)
  • Wykorzystanie wyjątków (224)

11. Programowanie wielowątkowe (225)

  • Model wątków języka Java (226)
    • Priorytety wątków (227)
    • Synchronizacja (227)
    • Przekazywanie komunikatów (228)
    • Klasa Thread i interfejs Runnable (228)
  • Wątek główny (228)
  • Tworzenie wątku (230)
    • Implementacja interfejsu Runnable (230)
    • Rozszerzanie klasy Thread (232)
    • Wybór odpowiedniego podejścia (232)
  • Tworzenie wielu wątków (233)
  • Stosowanie metod isAlive() i join() (234)
  • Priorytety wątków (236)
  • Synchronizacja (237)
    • Synchronizacja metod (237)
    • Instrukcja synchronized (239)
  • Komunikacja międzywątkowa (240)
    • Zakleszczenie (244)
  • Zawieszanie, wznawianie i zatrzymywanie wątków (245)
  • Uzyskiwanie stanu wątku (247)
  • Korzystanie z wielowątkowości (249)

12. Wyliczenia, automatyczne opakowywanie typów prostych i adnotacje (metadane) (251)

  • Typy wyliczeniowe (251)
    • Podstawy wyliczeń (251)
    • Metody values() i valueOf() (253)
    • Wyliczenia Javy jako typy klasowe (254)
    • Wyliczenia dziedziczą po klasie Enum (256)
    • Inny przykład wyliczenia (257)
  • Opakowania typów (258)
    • Klasa Character (259)
    • Klasa Boolean (259)
    • Opakowania typów numerycznych (259)
  • Automatyczne opakowywanie typów prostych (260)
    • Automatyczne opakowywanie i metody (261)
    • Automatyczne opakowywanie i rozpakowywanie w wyrażeniach (262)
    • Automatyczne opakowywanie typów znakowych i logicznych (263)
    • Automatyczne opakowywanie pomaga zapobiegać błędom (264)
    • Słowo ostrzeżenia (264)
  • Adnotacje (metadane) (265)
    • Podstawy tworzenia adnotacji (265)
    • Określanie strategii zachowywania adnotacji (266)
    • Odczytywanie adnotacji w trakcie działania programu za pomocą refleksji (266)
    • Interfejs AnnotatedElement (270)
    • Wartości domyślne (271)
    • Adnotacje znacznikowe (272)
    • Adnotacje jednoelementowe (272)
    • Wbudowane adnotacje (274)
  • Adnotacje typów (275)
  • Adnotacje powtarzalne (279)
    • Ograniczenia (281)

13. Wejście-wyjście, aplety i inne tematy (283)

  • Podstawowa obsługa wejścia i wyjścia (283)
    • Strumienie (284)
    • Strumienie znakowe i bajtowe (284)
    • Predefiniowane strumienie (286)
  • Odczyt danych z konsoli (286)
    • Odczyt znaków (286)
    • Odczyt łańcuchów (287)
  • Wyświetlanie informacji na konsoli (289)
  • Klasa PrintWriter (289)
  • Odczyt i zapis plików (290)
  • Automatyczne zamykanie pliku (295)
  • Podstawy apletów (298)
  • Modyfikatory transient i volatile (301)
  • Operator instanceof (301)
  • Modyfikator strictfp (303)
  • Metody napisane w kodzie rdzennym (303)
  • Problemy z metodami rdzennymi (306)
  • Stosowanie asercji (306)
    • Opcje włączania i wyłączania asercji (308)
  • Import statyczny (309)
  • Wywoływanie przeciążonych konstruktorów za pomocą this() (311)
  • Kompaktowe profile API (313)

14. Typy sparametryzowane (315)

  • Czym są typy sparametryzowane? (315)
  • Prosty przykład zastosowania typów sparametryzowanych (316)
    • Typy sparametryzowane działają tylko dla typów referencyjnych (319)
    • Typy sparametryzowane różnią się, jeśli mają inny argument typu (319)
    • W jaki sposób typy sparametryzowane zwiększają bezpieczeństwo? (319)
  • Klasa sparametryzowana z dwoma parametrami typu (321)
  • Ogólna postać klasy sparametryzowanej (322)
  • Typy ograniczone (322)
  • Zastosowanie argumentów wieloznacznych (324)
    • Ograniczony argument wieloznaczny (327)
  • Tworzenie metody sparametryzowanej (331)
    • Konstruktory sparametryzowane (332)
  • Interfejsy sparametryzowane (333)
  • Typy surowe i starszy kod (335)
  • Hierarchia klas sparametryzowanych (337)
    • Zastosowanie sparametryzowanej klasy bazowej (337)
    • Podklasa sparametryzowana (339)
    • Porównywanie typów w hierarchii klas sparametryzowanych w czasie wykonywania (340)
    • Rzutowanie (342)
    • Przykrywanie metod w klasach sparametryzowanych (342)
  • Wnioskowanie typów a typy sparametryzowane (343)
  • Znoszenie (344)
    • Metody mostu (344)
  • Błędy niejednoznaczności (346)
  • Pewne ograniczenia typów sparametryzowanych (347)
    • Nie można tworzyć egzemplarza parametru typu (347)
    • Ograniczenia dla składowych statycznych (347)
    • Ograniczenia tablic typów sparametryzowanych (347)
    • Ograniczenia wyjątków typów sparametryzowanych (348)

15. Wyrażenia lambda (349)

  • Wprowadzenie do wyrażeń lambda (349)
    • Podstawowe informacje o wyrażeniach lambda (350)
    • Interfejsy funkcyjne (351)
    • Kilka przykładów wyrażeń lambda (352)
  • Blokowe wyrażenia lambda (354)
  • Sparametryzowane interfejsy funkcyjne (356)
  • Przekazywanie wyrażeń lambda jako argumentów (357)
  • Wyrażenia lambda i wyjątki (360)
  • Wyrażenia lambda i przechwytywanie zmiennych (361)
  • Referencje do metod (362)
    • Referencje do metod statycznych (362)
    • Referencje do metod instancyjnych (363)
    • Referencje do metod a typy sparametryzowane (366)
  • Referencje do konstruktorów (368)
  • Predefiniowane interfejsy funkcyjne (372)

CZĘŚĆ II. BIBLIOTEKA JĘZYKA JAVA

16. Obsługa łańcuchów (377)

  • Konstruktory klasy String (377)
  • Długość łańcucha (379)
  • Specjalne operacje na łańcuchach (379)
    • Literały tekstowe (379)
    • Konkatenacja łańcuchów (380)
    • Konkatenacja łańcuchów z innymi typami danych (380)
    • Konwersja łańcuchów i metoda toString() (381)
  • Wyodrębnianie znaków (382)
    • Metoda charAt() (382)
    • Metoda getChars() (382)
    • Metoda getBytes() (382)
    • Metoda toCharArray() (383)
  • Porównywanie łańcuchów (383)
    • Metody equals() i equalsIgnoreCase() (383)
    • Metoda regionMatches() (384)
    • Metody startsWith() i endsWith() (384)
    • Metoda equals() kontra operator == (384)
    • Metoda compareTo() (385)
  • Przeszukiwanie łańcuchów (386)
  • Modyfikowanie łańcucha (387)
    • Metoda substring() (387)
    • Metoda concat() (388)
    • Metoda replace() (388)
    • Metoda trim() (389)
  • Konwersja danych za pomocą metody valueOf() (389)
  • Zmiana wielkości liter w łańcuchu (390)
  • Łączenie łańcuchów (390)
  • Dodatkowe metody klasy String (391)
  • Klasa StringBuffer (391)
    • Konstruktory klasy StringBuffer (391)
    • Metody length() i capacity() (393)
    • Metoda ensureCapacity() (393)
    • Metoda setLength() (393)
    • Metody charAt() i setCharAt() (393)
    • Metoda getChars() (394)
    • Metoda append() (394)
    • Metoda insert() (395)
    • Metoda reverse() (395)
    • Metody delete() i deleteCharAt() (395)
    • Metoda replace() (396)
    • Metoda substring() (396)
    • Dodatkowe metody klasy StringBuffer (397)
  • Klasa StringBuilder (398)

17. Pakiet java.lang (399)

  • Opakowania typów prostych (399)
    • Klasa Number (400)
    • Klasy Double i Float (400)
    • Klasy Byte, Short, Integer i Long (403)
    • Klasa Character (411)
    • Dodatki wprowadzone w celu obsługi punktów kodowych Unicode (413)
    • Klasa Boolean (414)
  • Klasa Void (415)
  • Klasa Process (415)
  • Klasa Runtime (416)
    • Zarządzanie pamięcią (416)
    • Wykonywanie innych programów (418)
  • Klasa ProcessBuilder (419)
  • Klasa System (421)
    • Wykorzystanie metody currentTimeMillis() do obliczania czasu wykonywania programu (422)
    • Użycie metody arraycopy() (423)
    • Właściwości środowiska (424)
  • Klasa Object (424)
  • Wykorzystanie metody clone() i interfejsu Cloneable (425)
  • Klasa Class (426)
  • Klasa ClassLoader (429)
  • Klasa Math (429)
    • Funkcje trygonometryczne (429)
    • Funkcje wykładnicze (430)
    • Funkcje zaokrągleń (430)
    • Inne metody klasy Math (430)
  • Klasa StrictMath (433)
  • Klasa Compiler (433)
  • Klasy Thread i ThreadGroup oraz interfejs Runnable (433)
    • Interfejs Runnable (433)
    • Klasa Thread (433)
    • Klasa ThreadGroup (435)
  • Klasy ThreadLocal i InheritableThreadLocal (439)
  • Klasa Package (439)
  • Klasa RuntimePermission (439)
  • Klasa Throwable (439)
  • Klasa SecurityManager (439)
  • Klasa StackTraceElement (439)
  • Klasa Enum (441)
  • Klasa ClassValue (442)
  • Interfejs CharSequence (442)
  • Interfejs Comparable (442)
  • Interfejs Appendable (442)
  • Interfejs Iterable (443)
  • Interfejs Readable (443)
  • Interfejs AutoCloseable (443)
  • Interfejs Thread.UncaughtExceptionHandler (444)
  • Podpakiety pakietu java.lang (444)
    • Podpakiet java.lang.annotation (444)
    • Podpakiet java.lang.instrument (444)
    • Podpakiet java.lang.invoke (444)
    • Podpakiet java.lang.management (444)
    • Podpakiet java.lang.ref (445)
    • Podpakiet java.lang.reflect (445)

18. Pakiet java.util, część 1. - kolekcje (447)

  • Wprowadzenie do kolekcji (448)
  • Zmiany w kolekcjach wprowadzone w JDK 5 (449)
    • Typy sparametryzowane w znaczący sposób zmieniają kolekcje (449)
    • Automatyczne opakowywanie ułatwia korzystanie z typów prostych (450)
    • Pętla for typu for-each (450)
  • Interfejsy kolekcji (450)
    • Interfejs Collection (451)
    • Interfejs List (453)
    • Interfejs Set (454)
    • Interfejs SortedSet (454)
    • Interfejs NavigableSet (455)
    • Interfejs Queue (455)
    • Interfejs Deque (455)
  • Klasy kolekcji (458)
    • Klasa ArrayList (458)
    • Klasa LinkedList (461)
    • Klasa HashSet (462)
    • Klasa LinkedHashSet (463)
    • Klasa TreeSet (464)
    • Klasa PriorityQueue (465)
    • Klasa ArrayDeque (465)
    • Klasa EnumSet (466)
  • Dostęp do kolekcji za pomocą iteratora (466)
    • Korzystanie z iteratora Iterator (468)
    • Pętla typu for-each jako alternatywa dla iteratora (469)
  • Spliteratory (470)
  • Przechowywanie w kolekcjach własnych klas (473)
  • Interfejs RandomAccess (474)
  • Korzystanie z map (474)
    • Interfejsy map (474)
    • Klasy map (479)
  • Komparatory (483)
    • Wykorzystanie komparatora (485)
  • Algorytmy kolekcji (490)
  • Klasa Arrays (495)
  • Starsze klasy i interfejsy (499)
    • Interfejs Enumeration (499)
    • Klasa Vector (500)
    • Klasa Stack (503)
    • Klasa Dictionary (504)
    • Klasa Hashtable (505)
    • Klasa Properties (508)
    • Wykorzystanie metod store() i load() (510)
  • Ostatnie uwagi na temat kolekcji (512)

19. Pakiet java.util, część 2. - pozostałe klasy użytkowe (513)

  • Klasa StringTokenizer (513)
  • Klasa BitSet (514)
  • Klasy Optional, OptionalDouble, OptionalInt oraz OptionalLong (517)
  • Klasa Date (519)
  • Klasa Calendar (521)
  • Klasa GregorianCalendar (524)
  • Klasa TimeZone (525)
  • Klasa SimpleTimeZone (525)
  • Klasa Locale (527)
  • Klasa Random (528)
  • Klasa Observable (530)
    • Interfejs Observer (531)
    • Przykład użycia interfejsu Observer (531)
  • Klasy Timer i TimerTask (533)
  • Klasa Currency (535)
  • Klasa Formatter (536)
    • Konstruktory klasy Formatter (536)
    • Metody klasy Formatter (537)
    • Podstawy formatowania (537)
    • Formatowanie łańcuchów i znaków (539)
    • Formatowanie liczb (540)
    • Formatowanie daty i godziny (540)
    • Specyfikatory %n i %% (542)
    • Określanie minimalnej szerokości pola (543)
    • Określanie precyzji (544)
    • Używanie znaczników (flag) formatów (545)
    • Wyrównywanie danych wyjściowych (545)
    • Znaczniki spacji, plusa, zera i nawiasów (546)
    • Znacznik przecinka (547)
    • Znacznik # (547)
    • Opcja wielkich liter (547)
    • Stosowanie indeksu argumentu (548)
    • Zamykanie obiektu klasy Formatter (549)
    • Metoda printf() w Javie (549)
  • Klasa Scanner (549)
    • Konstruktory klasy Scanner (549)
    • Podstawy skanowania (551)
    • Kilka przykładów użycia klasy Scanner (554)
    • Ustawianie separatorów (557)
    • Pozostałe elementy klasy Scanner (558)
  • Klasy ResourceBundle, ListResourceBundle i PropertyResourceBundle (559)
  • Dodatkowe klasy i interfejsy użytkowe (563)
  • Podpakiety pakietu java.util (564)
    • java.util.concurrent, java.util.concurrent.atomic oraz java.util.concurrent.locks (564)
    • java.util.function (564)
    • java.util.jar (567)
    • java.util.logging (567)
    • java.util.prefs (567)
    • java.util.regex (567)
    • java.util.spi (567)
    • java.util.stream (567)
    • java.util.zip (567)

20. Operacje wejścia-wyjścia: analiza pakietu java.io (569)

  • Klasy i interfejsy obsługujące operacje wejścia-wyjścia (570)
  • Klasa File (570)
    • Katalogi (573)
    • Stosowanie interfejsu FilenameFilter (574)
    • Alternatywna metoda listFiles() (575)
    • Tworzenie katalogów (575)
  • Interfejsy AutoCloseable, Closeable i Flushable (575)
  • Wyjątki operacji wejścia-wyjścia (576)
  • Dwa sposoby zamykania strumieni (576)
  • Klasy strumieni (577)
  • Strumienie bajtów (578)
    • Klasa InputStream (578)
    • Klasa OutputStream (579)
    • Klasa FileInputStream (579)
    • Klasa FileOutputStream (581)
    • Klasa ByteArrayInputStream (583)
    • Klasa ByteArrayOutputStream (584)
    • Filtrowane strumienie bajtów (585)
    • Buforowane strumienie bajtów (586)
    • Klasa SequenceInputStream (589)
    • Klasa PrintStream (590)
    • Klasy DataOutputStream i DataInputStream (593)
    • Klasa RandomAccessFile (594)
  • Strumienie znaków (595)
    • Klasa Reader (595)
    • Klasa Writer (596)
    • Klasa FileReader (596)
    • Klasa FileWriter (597)
    • Klasa CharArrayReader (598)
    • Klasa CharArrayWriter (599)
    • Klasa BufferedReader (600)
    • Klasa BufferedWriter (601)
    • Klasa PushbackReader (601)
    • Klasa PrintWriter (602)
  • Klasa Console (603)
  • Serializacja (605)
    • Interfejs Serializable (606)
    • Interfejs Externalizable (606)
    • Interfejs ObjectOutput (606)
    • Klasa ObjectOutputStream (607)
    • Interfejs ObjectInput (608)
    • Klasa ObjectInputStream (608)
    • Przykład serializacji (608)
  • Korzyści wynikające ze stosowania strumieni (610)

21. System NIO (611)

  • Klasy systemu NIO (611)
  • Podstawy systemu NIO (612)
    • Bufory (612)
    • Kanały (613)
    • Zestawy znaków i selektory (614)
  • Udoskonalenia dodane do systemu NIO w wydaniu JDK 7 (615)
    • Interfejs Path (615)
    • Klasa Files (615)
    • Klasa Paths (618)
    • Interfejsy atrybutów plików (619)
    • Klasy FileSystem, FileSystems i FileStore (620)
  • Stosowanie systemu NIO (621)
    • Stosowanie systemu NIO dla operacji wejścia-wyjścia na kanałach (621)
    • Stosowanie systemu NIO dla operacji wejścia-wyjścia na strumieniach (629)
    • Stosowanie systemu NIO dla operacji na ścieżkach i systemie plików (631)
  • Przykłady stosowania kanałów w wersjach sprzed JDK 7 (638)
    • Odczytywanie plików (wersje sprzed JDK 7) (638)
    • Zapisywanie plików (wersje sprzed JDK 7) (641)

22. Obsługa sieci (645)

  • Podstawy działania sieci (645)
  • Klasy i interfejsy obsługujące komunikację sieciową (646)
  • Klasa InetAddress (647)
    • Metody fabryczne (647)
    • Metody klasy (648)
  • Klasy Inet4Address oraz Inet6Address (649)
  • Gniazda klientów TCP/IP (649)
  • URL (652)
  • Klasa URLConnection (654)
  • Klasa HttpURLConnection (656)
  • Klasa URI (658)
  • Pliki cookie (658)
  • Gniazda serwerów TCP/IP (658)
  • Datagramy (659)
    • Klasa DatagramSocket (659)
    • Klasa DatagramPacket (660)
    • Przykład użycia datagramów (660)

23. Klasa Applet (663)

  • Dwa rodzaje apletów (663)
  • Podstawy apletów (664)
    • Klasa Applet (665)
  • Architektura apletu (667)
  • Szkielet apletu (667)
    • Inicjalizacja i przerywanie działania apletu (668)
    • Przykrycie metody update() (669)
  • Proste metody wyświetlania składników apletów (670)
  • Żądanie ponownego wyświetlenia (671)
    • Prosty aplet z paskiem reklamowym (672)
  • Wykorzystywanie paska stanu (674)
  • Znacznik APPLET języka HTML (675)
  • Przekazywanie parametrów do apletów (676)
    • Udoskonalenie apletu z paskiem reklamowym (677)
  • Metody getDocumentBase() i getCodeBase() (679)
  • Interfejs AppletContext i metoda showDocument() (679)
  • Interfejs AudioClip (681)
  • Interfejs AppletStub (681)
  • Wyświetlanie danych wyjściowych na konsoli (681)

24. Obsługa zdarzeń (683)

  • Dwa mechanizmy obsługi zdarzeń (683)
  • Model obsługi zdarzeń oparty na ich delegowaniu (684)
    • Zdarzenia (684)
    • Źródła zdarzeń (684)
    • Obiekty nasłuchujące zdarzeń (685)
  • Klasy zdarzeń (685)
    • Klasa ActionEvent (686)
    • Klasa AdjustmentEvent (687)
    • Klasa ComponentEvent (688)
    • Klasa ContainerEvent (688)
    • Klasa FocusEvent (689)
    • Klasa InputEvent (689)
    • Klasa ItemEvent (690)
  • Klasa KeyEvent (691)
    • Klasa MouseEvent (691)
    • Klasa MouseWheelEvent (693)
    • Klasa TextEvent (694)
    • Klasa WindowEvent (694)
  • Źródła zdarzeń (695)
  • Interfejsy nasłuchujące zdarzeń (696)
    • Interfejs ActionListener (696)
    • Interfejs AdjustmentListener (696)
    • Interfejs ComponentListener (697)
    • Interfejs ContainerListener (697)
    • Interfejs FocusListener (697)
    • Interfejs ItemListener (697)
    • Interfejs KeyListener (697)
    • Interfejs MouseListener (697)
    • Interfejs MouseMotionListener (698)
    • Interfejs MouseWheelListener (698)
    • Interfejs TextListener (698)
    • Interfejs WindowFocusListener (698)
    • Interfejs WindowListener (698)
  • Stosowanie modelu delegowania zdarzeń (699)
    • Obsługa zdarzeń generowanych przez mysz (699)
    • Obsługa zdarzeń generowanych przez klawiaturę (701)
  • Klasy adapterów (704)
  • Klasy wewnętrzne (705)
    • Anonimowa klasa wewnętrzna (707)

25. Wprowadzenie do AWT: praca z oknami, grafiką i tekstem (709)

  • Klasy AWT (710)
  • Podstawy okien (712)
    • Klasa Component (712)
    • Klasa Container (712)
    • Klasa Panel (713)
    • Klasa Window (713)
    • Klasa Frame (713)
    • Klasa Canvas (713)
  • Praca z oknami typu Frame (713)
    • Ustawianie wymiarów okna (714)
    • Ukrywanie i wyświetlanie okna (714)
    • Ustawianie tytułu okna (714)
    • Zamykanie okna typu Frame (714)
  • Tworzenie okna typu Frame w aplecie AWT (714)
    • Obsługa zdarzeń w oknie typu Frame (716)
  • Tworzenie programu wykorzystującego okna (720)
  • Wyświetlanie informacji w oknie (721)
  • Wprowadzenie do stosowania grafiki (722)
    • Rysowanie odcinków (722)
    • Rysowanie prostokątów (722)
    • Rysowanie elips, kół i okręgów (723)
    • Rysowanie łuków (723)
    • Rysowanie wielokątów (723)
    • Prezentacja metod rysujących (723)
    • Dostosowywanie rozmiarów obiektów graficznych (725)
  • Praca z klasą Color (725)
    • Metody klasy Color (726)
    • Ustawianie bieżącego koloru kontekstu graficznego (727)
    • Aplet demonstrujący zastosowanie klasy Color (727)
  • Ustawianie trybu rysowania (728)
  • Praca z czcionkami (729)
    • Określanie dostępnych czcionek (730)
    • Tworzenie i wybieranie czcionek (731)
    • Uzyskiwanie informacji o czcionkach (733)
  • Zarządzanie tekstowymi danymi wyjściowymi z wykorzystaniem klasy FontMetrics (734)
    • Wyświetlanie tekstu w wielu wierszach (735)
    • Wyśrodkowanie tekstu (737)
    • Wyrównywanie wielowierszowych danych tekstowych (737)

26. Stosowanie kontrolek AWT, menedżerów układu graficznego oraz menu (741)

  • Podstawy kontrolek AWT (742)
    • Dodawanie i usuwanie kontrolek (742)
    • Odpowiadanie na zdarzenia kontrolek (742)
    • Wyjątek HeadlessException (743)
  • Etykiety (743)
  • Stosowanie przycisków (744)
    • Obsługa zdarzeń przycisków (744)
  • Stosowanie pól wyboru (747)
    • Obsługa zdarzeń pól wyboru (748)
  • Klasa CheckboxGroup (749)
  • Kontrolki list rozwijanych (751)
    • Obsługa zdarzeń list rozwijanych (751)
  • Stosowanie list (753)
    • Obsługa zdarzeń generowanych przez listy (754)
  • Zarządzanie paskami przewijania (755)
    • Obsługa zdarzeń generowanych przez paski przewijania (756)
  • Stosowanie kontrolek typu TextField (758)
    • Obsługa zdarzeń generowanych przez kontrolkę TextField (759)
  • Stosowanie kontrolek typu TextArea (760)
  • Wprowadzenie do menedżerów układu graficznego komponentów (762)
    • FlowLayout (762)
    • BorderLayout (764)
    • Stosowanie obramowań (766)
    • GridLayout (767)
    • Klasa CardLayout (768)
    • Klasa GridBagLayout (771)
  • Menu i paski menu (775)
  • Okna dialogowe (780)
  • FileDialog (784)
  • Przykrywanie metody paint() (786)

27. Obrazy (787)

  • Formaty plików (787)
  • Podstawy przetwarzania obrazów: tworzenie, wczytywanie i wyświetlanie (788)
    • Tworzenie obiektu obrazu (788)
    • Ładowanie obrazu (788)
    • Wyświetlanie obrazu (789)
  • Interfejs ImageObserver (790)
  • Podwójne buforowanie (791)
  • Klasa MediaTracker (793)
  • Interfejs ImageProducer (796)
    • Klasa MemoryImageSource (796)
  • Interfejs ImageConsumer (797)
    • Klasa PixelGrabber (797)
  • Klasa ImageFilter (799)
    • Klasa CropImageFilter (800)
    • Klasa RGBImageFilter (801)
  • Dodatkowe klasy obsługujące obrazy (810)

28. Narzędzia współbieżności (811)

  • Pakiety interfejsu Concurrent API (812)
    • Pakiet java.util.concurrent (812)
    • Pakiet java.util.concurrent.atomic (813)
    • Pakiet java.util.concurrent.locks (813)
  • Korzystanie z obiektów służących do synchronizacji (813)
    • Klasa Semaphore (813)
    • Klasa CountDownLatch (818)
    • CyclicBarrier (819)
    • Klasa Exchanger (821)
  • Klasa Phaser (823)
  • Korzystanie z egzekutorów (830)
    • Przykład prostego egzekutora (830)
    • Korzystanie z interfejsów Callable i Future (832)
  • Typ wyliczeniowy TimeUnit (834)
  • Kolekcje współbieżne (835)
  • Blokady (835)
  • Operacje atomowe (838)
  • Programowanie równoległe przy użyciu frameworku Fork/Join (839)
    • Najważniejsze klasy frameworku Fork/Join (839)
    • Strategia dziel i zwyciężaj (843)
    • Prosty przykład użycia frameworku Fork/Join (843)
    • Znaczenie poziomu równoległości (845)
    • Przykład użycia klasy RecursiveTask<V> (848)
    • Asynchroniczne wykonywanie zadań (850)
    • Anulowanie zadania (850)
    • Określanie statusu wykonania zadania (851)
    • Ponowne uruchamianie zadania (851)
    • Pozostałe zagadnienia (851)
    • Wskazówki dotyczące stosowania frameworku Fork/Join (853)
  • Pakiet Concurrency Utilities a tradycyjne metody języka Java (853)

29. API strumieni (855)

  • Podstawowe informacje o strumieniach (855)
    • Interfejsy strumieni (856)
    • Jak można uzyskać strumień? (858)
    • Prosty przykład stosowania strumieni (859)
  • Operacje redukcji (862)
  • Stosowanie strumieni równoległych (864)
  • Odwzorowywanie (866)
  • Tworzenie kolekcji (870)
  • Iteratory i strumienie (873)
    • Stosowanie typu Iterator i strumieni (873)
    • Stosowanie spliteratorów (874)
  • Inne możliwości API strumieni (877)

30. Wyrażenia regularne i inne pakiety (879)

  • Pakiety głównego API języka Java (879)
  • Przetwarzanie wyrażeń regularnych (879)
    • Klasa Pattern (881)
    • Klasa Matcher (882)
    • Składnia wyrażeń regularnych (882)
    • Przykład dopasowywania do wzorca (883)
    • Dwie opcje dopasowywania do wzorca (887)
    • Przegląd wyrażeń regularnych (888)
  • Refleksje (888)
  • Zdalne wywoływanie metod (RMI) (891)
    • Prosta aplikacja typu klient-serwer wykorzystująca RMI (891)
  • Formatowanie dat i czasu przy użyciu pakietu java.text (894)
    • Klasa DateFormat (894)
    • Klasa SimpleDateFormat (896)
  • Interfejs API dat i czasu dodany w JDK 8 (897)
    • Podstawowe klasy do obsługi dat i czasu (898)
    • Formatowanie dat i godzin (899)
    • Analiza łańcuchów zawierających daty i godziny (901)
    • Inne możliwości pakietu java.time (902)

CZĘŚĆ III. WPROWADZENIE DO PROGRAMOWANIA GUI PRZY UŻYCIU PAKIETU SWING

31. Wprowadzenie do pakietu Swing (905)

  • Geneza powstania biblioteki Swing (905)
  • Bibliotekę Swing zbudowano na bazie zestawu narzędzi AWT (906)
  • Podstawowe cechy biblioteki Swing (906)
    • Komponenty biblioteki Swing są lekkie (906)
    • Biblioteka Swing obsługuje dołączany wygląd i sposób obsługi (907)
  • Podobieństwo do architektury MVC (907)
  • Komponenty i kontenery (908)
    • Komponenty (908)
    • Kontenery (909)
    • Panele kontenerów najwyższego poziomu (909)
  • Pakiety biblioteki Swing (910)
  • Prosta aplikacja na bazie biblioteki Swing (910)
  • Obsługa zdarzeń (914)
  • Tworzenie apletu na bazie biblioteki Swing (917)
  • Rysowanie w bibliotece Swing (919)
    • Podstawy rysowania (919)
    • Wyznaczanie obszaru rysowania (920)
    • Przykład rysowania (920)

32. Przewodnik po pakiecie Swing (923)

  • Klasy JLabel i ImageIcon (923)
  • Klasa JTextField (925)
  • Przyciski biblioteki Swing (926)
    • Klasa JButton (927)
    • Klasa JToggleButton (929)
    • Pola wyboru (931)
    • Przyciski opcji (932)
  • Klasa JTabbedPane (934)
  • Klasa JScrollPane (936)
  • Klasa JList (938)
  • Klasa JComboBox (941)
  • Drzewa (943)
  • Klasa JTable (945)

33. Wprowadzenie do systemu menu pakietu Swing (949)

  • Podstawy systemu menu (949)
  • Przegląd klas JMenuBar, JMenu oraz JMenuItem (951)
    • Klasa JMenuBar (951)
    • Klasa JMenu (952)
    • Klasa JMenuItem (953)
  • Tworzenie menu głównego (953)
  • Dodawanie mnemonik i kombinacji klawiszy do opcji menu (957)
  • Dodawanie obrazów i etykiet ekranowych do menu (959)
  • Stosowanie klas JRadioButtonMenuItem oraz JCheckBoxMenuItem (960)
  • Tworzenie menu podręcznych (962)
  • Tworzenie paska narzędzi (964)
  • Stosowanie akcji (967)
  • Finalna postać programu MenuDemo (971)
  • Dalsze poznawanie pakietu Swing (977)

CZĘŚĆ IV. WPROWADZENIE DO PROGRAMOWANIA GUI PRZY UŻYCIU PLATFORMY JAVAFX

34. Wprowadzenie do tworzenia interfejsów graficznych z użyciem JavaFX (981)

  • Podstawowe pojęcia z zakresu JavaFX (982)
    • Pakiety JavaFX (982)
    • Klasy Stage oraz Scene (982)
    • Węzły i graf sceny (983)
    • Układy (983)
    • Klasa Application i metody cyklu życia (983)
    • Uruchamianie aplikacji JavaFX (984)
  • Szkielet aplikacji JavaFX (984)
  • Kompilacja i uruchamianie programów JavaFX (987)
  • Wątek aplikacji (988)
  • Prosta kontrolka JavaFX: Label (988)
  • Stosowanie przycisków i zdarzeń (990)
    • Podstawowe informacje o zdarzeniach (990)
    • Prezentacja kontrolki Button (991)
    • Przedstawienie obsługi zdarzeń i kontrolki Button (992)
  • Bezpośrednie rysowanie na płótnie (994)

35. Prezentacja kontrolek JavaFX (999)

  • Stosowanie klas Image i ImageView (999)
    • Dodawanie obrazów do etykiet (1001)
    • Stosowanie obrazów w przyciskach (1003)
  • Kontrolka ToggleButton (1005)
  • Kontrolka RadioButton (1008)
    • Obsługa zdarzeń w grupie (1010)
    • Alternatywne sposoby obsługi przycisków opcji (1011)
  • Kontrolka CheckBox (1014)
  • Kontrolka ListView (1017)
    • Paski przewijania w kontrolkach ListView (1020)
    • Włączanie możliwości wielokrotnego wyboru (1021)
  • Kontrolka ComboBox (1022)
  • Kontrolka TextField (1024)
  • Kontrolka ScrollPane (1026)
  • Kontrolka TreeView (1029)
  • Prezentacja efektów i transformacji (1033)
    • Efekty (1034)
    • Transformacje (1035)
    • Prezentacja zastosowania efektów i transformacji (1036)
  • Dodawanie etykiet ekranowych (1038)
    • Dezaktywacja kontrolek (1039)

36. Prezentacja systemu menu platformy JavaFX (1041)

  • Podstawowe informacje o menu (1041)
  • Prezentacja klas MenuBar, Menu oraz MenuItem (1043)
    • Klasa MenuBar (1043)
    • Klasa Menu (1043)
    • Klasa MenuItem (1044)
  • Tworzenie menu głównego (1045)
  • Dodawanie mnemonik i akceleratorów do elementów menu (1049)
  • Dodawanie obrazów do elementów menu (1051)
  • Stosowanie klas RadioMenuItem i CheckMenuItem (1051)
  • Tworzenie menu podręcznego (1053)
  • Tworzenie paska narzędzi (1057)
  • Kompletna nowa wersja programu demonstracyjnego (1059)
  • Dalsze poznawanie platformy JavaFX (1064)

CZĘŚĆ V. STOSOWANIE JAVY W PRAKTYCE

37. Java Beans (1067)

  • Czym jest komponent typu Java Bean? (1067)
  • Zalety komponentów Java Beans (1068)
  • Introspekcja (1068)
    • Wzorce właściwości (1068)
    • Wzorce projektowe dla zdarzeń (1069)
    • Metody i wzorce projektowe (1070)
    • Korzystanie z interfejsu BeanInfo (1070)
  • Właściwości ograniczone (1070)
  • Trwałość (1071)
  • Interfejs Customizer (1071)
  • Interfejs Java Beans API (1071)
    • Klasa Introspector (1073)
    • Klasa PropertyDescriptor (1073)
    • Klasa EventSetDescriptor (1073)
    • Klasa MethodDescriptor (1073)
  • Przykład komponentu Java Bean (1073)

38. Serwlety (1077)

  • Podstawy (1077)
  • Cykl życia serwletu (1078)
  • Alternatywne sposoby tworzenia serwletów (1078)
  • Korzystanie z serwera Tomcat (1079)
  • Przykład prostego serwletu (1080)
    • Tworzenie i kompilacja kodu źródłowego serwletu (1080)
    • Uruchamianie serwera Tomcat (1081)
    • Uruchamianie przeglądarki i generowanie żądania (1081)
  • Interfejs Servlet API (1081)
  • Pakiet javax.servlet (1081)
    • Interfejs Servlet (1082)
    • Interfejs ServletConfig (1082)
    • Interfejs ServletContext (1083)
    • Interfejs ServletRequest (1083)
    • Interfejs ServletResponse (1083)
    • Klasa GenericServlet (1083)
    • Klasa ServletInputStream (1083)
    • Klasa ServletOutputStream (1085)
    • Klasy wyjątków związanych z serwletami (1085)
  • Odczytywanie parametrów serwletu (1085)
  • Pakiet javax.servlet.http (1086)
    • Interfejs HttpServletRequest (1087)
    • Interfejs HttpServletResponse (1087)
    • Interfejs HttpSession (1087)
    • Klasa Cookie (1089)
    • Klasa HttpServlet (1090)
  • Obsługa żądań i odpowiedzi HTTP (1090)
    • Obsługa żądań GET protokołu HTTP (1090)
    • Obsługa żądań POST protokołu HTTP (1092)
  • Korzystanie ze znaczników kontekstu użytkownika (1093)
  • Śledzenie sesji (1095)

DODATKI A. Komentarze dokumentujące (1099)

  • Znaczniki narzędzia javadoc (1099)
    • Znacznik @author (1100)
    • Znacznik {@code} (1100)
    • Znacznik @deprecated (1100)
    • Znacznik {@docRoot} (1101)
    • Znacznik @exception (1101)
    • Znacznik {@inheritDoc} (1101)
    • Znacznik {@link} (1101)
    • Znacznik {@linkplain} (1101)
    • Znacznik {@literal} (1101)
    • Znacznik @param (1101)
    • Znacznik @return (1101)
    • Znacznik @see (1102)
    • Znacznik @serial (1102)
    • Znacznik @serialData (1102)
    • Znacznik @serialField (1102)
    • Znacznik @since (1102)
    • Znacznik @throws (1102)
    • Znacznik {@value} (1102)
    • Znacznik @version (1103)
  • Ogólna postać komentarzy dokumentacyjnych (1103)
  • Wynik działania narzędzia javadoc (1103)
  • Przykład korzystający z komentarzy dokumentacyjnych (1103)

Skorowidz (1105)

Informatyka » Java - Programowanie

https://facebook.com/wiedzanaplus
Alt + 9
Pomoc ( Alt + 0 )
Loading...