Java 8. Przewodnik doświadczonego programisty

Spis treści książki

Wstęp (15)

Podziękowania (17)

O autorze (19)

Rozdział 1. Podstawowe struktury programistyczne (21)

• 1.1. Nasz pierwszy program (22)
  • 1.1.1. Analiza programu "Witaj, świecie!" (22)
  • 1.1.2. Kompilacja i uruchamianie programu w języku Java (24)
  • 1.1.3. Wywołania metod (25)
• 1.2. Typy proste (27)
  • 1.2.1. Typy całkowite (27)
  • 1.2.2. Typy zmiennoprzecinkowe (28)
  • 1.2.3. Typ char (29)
  • 1.2.4. Typ boolean (30)
• 1.3. Zmienne (30)
  • 1.3.1. Deklaracje zmiennych (30)
  • 1.3.2. Nazwy (31)
  • 1.3.3. Inicjalizacja (31)
  • 1.3.4. Stałe (31)
• 1.4. Działania arytmetyczne (33)
  • 1.4.1. Przypisanie (33)
  • 1.4.2. Podstawowa arytmetyka (34)
  • 1.4.3. Metody matematyczne (35)
  • 1.4.4. Konwersja typów liczbowych (36)
  • 1.4.5. Operatory relacji i operatory logiczne (37)
  • 1.4.6. Duże liczby (39)
• 1.5. Ciągi znaków (39)
  • 1.5.1. Łączenie ciągów znaków (40)
  • 1.5.2. Wycinanie ciągów znaków (40)
  • 1.5.3. Porównywanie ciągów znaków (41)
  • 1.5.4. Konwersja liczb na znaki i znaków na liczby (42)
  • 1.5.5. API klasy String (43)
  • 1.5.6. Kodowanie znaków w języku Java (44)
• 1.6. Wejście i wyjście (46)
  • 1.6.1. Wczytywanie danych wejściowych (46)
  • 1.6.2. Formatowanie generowanych danych (47)
• 1.7. Kontrola przepływu (49)
  • 1.7.1. Instrukcje warunkowe (49)
  • 1.7.2. Pętle (51)
  • 1.7.3. Przerywanie i kontynuacja (52)
  • 1.7.4. Zasięg zmiennych lokalnych (54)
• 1.8. Tablice i listy tablic (55)
  • 1.8.1. Obsługa tablic (55)
  • 1.8.2. Tworzenie tablicy (56)
  • 1.8.3. Klasa ArrayList (57)
  • 1.8.4. Klasy opakowujące typy proste (58)
  • 1.8.5. Rozszerzona pętla for (59)
  • 1.8.6. Kopiowanie tablic i obiektów ArrayList (59)
  • 1.8.7. Algorytmy tablic (60)
  • 1.8.8. Parametry wiersza poleceń (61)
  • 1.8.9. Tablice wielowymiarowe (62)
• 1.9. Dekompozycja funkcjonalna (64)
  • 1.9.1. Deklarowanie i wywoływanie metod statycznych (64)
  • 1.9.2. Parametry tablicowe i zwracane wartości (65)
  • 1.9.3. Zmienna liczba parametrów (65)
• Ćwiczenia (66)

Rozdział 2. Programowanie obiektowe (69)

• 2.1. Praca z obiektami (70)
  • 2.1.1. Metody dostępowe i modyfikujące (72)
  • 2.1.2. Referencje do obiektu (72)
• 2.2. Implementowanie klas (74)
  • 2.2.1. Zmienne instancji (74)
  • 2.2.2. Nagłówki metod (75)
  • 2.2.3. Treści metod (75)
  • 2.2.4. Wywołania metod instancji (76)
  • 2.2.5. Referencja this (76)
  • 2.2.6. Wywołanie przez wartość (77)
• 2.3. Tworzenie obiektów (78)
  • 2.3.1. Implementacja konstruktorów (78)
  • 2.3.2. Przeciążanie (79)
  • 2.3.3. Wywoływanie jednego konstruktora z innego (80)
  • 2.3.4. Domyślna inicjalizacja (80)
  • 2.3.5. Inicjalizacja zmiennych instancji (81)
  • 2.3.6. Zmienne instancji z modyfikatorem final (81)
  • 2.3.7. Konstruktor bez parametrów (82)
• 2.4. Statyczne zmienne i metody (83)
  • 2.4.1. Zmienne statyczne (83)
  • 2.4.2. Stałe statyczne (83)
  • 2.4.3. Statyczne bloki inicjalizacyjne (84)
  • 2.4.4. Metody statyczne (85)
  • 2.4.5. Metody wytwórcze (86)
• 2.5. Pakiety (86)
  • 2.5.1. Deklarowanie pakietów (87)
  • 2.5.2. Ścieżka klas (88)
  • 2.5.3. Zasięg pakietu (90)
  • 2.5.4. Importowanie klas (91)
  • 2.5.5. Import metod statycznych (92)
• 2.6. Klasy zagnieżdżone (92)
  • 2.6.1. Statyczne klasy zagnieżdżone (92)
  • 2.6.2. Klasy wewnętrzne (94)
  • 2.6.3. Specjalne reguły składni dla klas wewnętrznych (96)
• 2.7. Komentarze do dokumentacji (97)
  • 2.7.1. Wstawianie komentarzy (97)
  • 2.7.2. Komentarze klasy (98)
  • 2.7.3. Komentarze metod (98)
  • 2.7.4. Komentarze zmiennych (99)
  • 2.7.5. Ogólne komentarze (99)
  • 2.7.6. Odnośniki (99)
  • 2.7.7. Opisy pakietów i ogólne (100)
  • 2.7.8. Wycinanie komentarzy (101)
• Ćwiczenia (101)

Rozdział 3. Interfejsy i wyrażenia lambda (105)

• 3.1. Interfejsy (106)
  • 3.1.1. Deklarowanie interfejsu (106)
  • 3.1.2. Implementowanie interfejsu (107)
  • 3.1.3. Konwersja do typu interfejsu (108)
  • 3.1.4. Rzutowanie i operator instanceof (109)
  • 3.1.5. Rozszerzanie interfejsów (110)
  • 3.1.6. Implementacja wielu interfejsów (110)
  • 3.1.7. Stałe (110)
• 3.2. Metody statyczne i domyślne (111)
  • 3.2.1. Metody statyczne (111)
  • 3.2.2. Metody domyślne (111)
  • 3.2.3. Rozstrzyganie konfliktów metod domyślnych (112)
• 3.3. Przykłady interfejsów (114)
  • 3.3.1. Interfejs Comparable (114)
  • 3.3.2. Interfejs Comparator (115)
  • 3.3.3. Interfejs Runnable (116)
  • 3.3.4. Wywołania zwrotne interfejsu użytkownika (117)
• 3.4. Wyrażenia lambda (118)
  • 3.4.1. Składnia wyrażeń lambda (118)
  • 3.4.2. Interfejsy funkcyjne (119)
• 3.5. Referencje do metod i konstruktora (120)
  • 3.5.1. Referencje do metod (121)
  • 3.5.2. Referencje konstruktora (122)
• 3.6. Przetwarzanie wyrażeń lambda (123)
  • 3.6.1. Implementacja odroczonego wykonania (123)
  • 3.6.2. Wybór interfejsu funkcjonalnego (124)
  • 3.6.3. Implementowanie własnych interfejsów funkcjonalnych (125)
• 3.7. Wyrażenia lambda i zasięg zmiennych (126)
  • 3.7.1. Zasięg zmiennej lambda (126)
  • 3.7.2. Dostęp do zmiennych zewnętrznych (127)
• 3.8. Funkcje wyższych rzędów (129)
  • 3.8.1. Metody zwracające funkcje (129)
  • 3.8.2. Metody modyfikujące funkcje (130)
  • 3.8.3. Metody interfejsu Comparator (130)
• 3.9. Lokalne klasy wewnętrzne (131)
  • 3.9.1. Klasy lokalne (131)
  • 3.9.2. Klasy anonimowe (132)
• Ćwiczenia (133)

Rozdział 4. Dziedziczenie i mechanizm refleksji (135)

• 4.1. Rozszerzanie klas (136)
  • 4.1.1. Klasy nadrzędne i podrzędne (136)
  • 4.1.2. Definiowanie i dziedziczenie metod klas podrzędnych (137)
  • 4.1.3. Przesłanianie metod (137)
  • 4.1.4. Tworzenie klasy podrzędnej (139)
  • 4.1.5. Przypisania klas nadrzędnych (139)
  • 4.1.6. Rzutowanie (140)
  • 4.1.7. Metody i klasy z modyfikatorem final (140)
  • 4.1.8. Abstrakcyjne metody i klasy (141)
  • 4.1.9. Ograniczony dostęp (142)
  • 4.1.10. Anonimowe klasy podrzędne (143)
  • 4.1.11. Dziedziczenie i metody domyślne (143)
  • 4.1.12. Wywołania metod z super (144)
• 4.2. Object - najwyższa klasa nadrzędna (145)
  • 4.2.1. Metoda toString (145)
  • 4.2.2. Metoda equals (147)
  • 4.2.3. Metoda hashCode (149)
  • 4.2.4. Klonowanie obiektów (150)
• 4.3. Wyliczenia (153)
  • 4.3.1. Sposoby wyliczania (153)
  • 4.3.2. Konstruktory, metody i pola (154)
  • 4.3.3. Zawartość elementów (155)
  • 4.3.4. Elementy statyczne (155)
  • 4.3.5. Wyrażenia switch ze stałymi wyliczeniowymi (156)
• 4.4. Informacje o typie i zasobach w czasie działania programu (157)
  • 4.4.1. Klasa Class (157)
  • 4.4.2. Wczytywanie zasobów (158)
  • 4.4.3. Programy wczytujące klasy (160)
  • 4.4.4. Kontekstowy program wczytujący klasy (162)
  • 4.4.5. Programy do ładowania usług (163)
• 4.5. Refleksje (165)
  • 4.5.1. Wyliczanie elementów klasy (165)
  • 4.5.2. Kontrolowanie obiektów (166)
  • 4.5.3. Wywoływanie metod (166)
  • 4.5.4. Tworzenie obiektów (167)
  • 4.5.5. JavaBeans (167)
  • 4.5.6. Praca z tablicami (169)
  • 4.5.7. Klasa Proxy (170)
• Ćwiczenia (172)

Rozdział 5. Wyjątki, asercje i logi (175)

• 5.1. Obsługa wyjątków (176)
  • 5.1.1. Wyrzucanie wyjątków (176)
  • 5.1.2. Hierarchia wyjątków (177)
  • 5.1.3. Deklarowanie wyjątków kontrolowanych (179)
  • 5.1.4. Przechwytywanie wyjątków (180)
  • 5.1.5. Wyrażenie try z określeniem zasobów (181)
  • 5.1.6. Klauzula finally (182)
  • 5.1.7. Ponowne wyrzucanie wyjątków i łączenie ich w łańcuchy (183)
  • 5.1.8. Śledzenie stosu (185)
  • 5.1.9. Metoda Objects.requireNonNull (185)
• 5.2. Asercje (186)
  • 5.2.1. Użycie asercji (186)
  • 5.2.2. Włączanie i wyłączanie asercji (187)
• 5.3. Rejestrowanie danych (188)
  • 5.3.1. Klasa Logger (188)
  • 5.3.2. Mechanizmy rejestrujące dane (188)
  • 5.3.3. Poziomy rejestrowania danych (189)
  • 5.3.4. Inne metody rejestrowania danych (189)
  • 5.3.5. Konfiguracja mechanizmów rejestrowania danych (191)
  • 5.3.6. Programy obsługujące rejestrowanie danych (192)
  • 5.3.7. Filtry i formaty (194)
• Ćwiczenia (195)

Rozdział 6. Programowanie uogólnione (197)

• 6.1. Klasy uogólnione (198)
• 6.2. Metody uogólnione (199)
• 6.3. Ograniczenia typów (200)
• 6.4. Zmienność typów i symbole wieloznaczne (201)
  • 6.4.1. Symbole wieloznaczne w typach podrzędnych (202)
  • 6.4.2. Symbole wieloznaczne typów nadrzędnych (202)
  • 6.4.3. Symbole wieloznaczne ze zmiennymi typami (203)
  • 6.4.4. Nieograniczone symbole wieloznaczne (205)
  • 6.4.5. Przechwytywanie symboli wieloznacznych (205)
• 6.5. Uogólnienia w maszynie wirtualnej Javy (206)
  • 6.5.1. Wymazywanie typów (206)
  • 6.5.2. Wprowadzanie rzutowania (207)
  • 6.5.3. Metody pomostowe (207)
• 6.6. Ograniczenia uogólnień (209)
  • 6.6.1. Brak typów prostych (209)
  • 6.6.2. W czasie działania kodu wszystkie typy są surowe (209)
  • 6.6.3. Nie możesz tworzyć instancji zmiennych opisujących typy (210)
  • 6.6.4. Nie możesz tworzyć tablic z parametryzowanym typem (212)
  • 6.6.5. Zmienne opisujące typ klasy nie są poprawne w kontekście statycznym (213)
  • 6.6.6. Metody nie mogą wywoływać konfliktów po wymazywaniu typów (213)
  • 6.6.7. Wyjątki i uogólnienia (214)
• 6.7. Refleksje i uogólnienia (215)
  • 6.7.1. Klasa Class (215)
  • 6.7.2. Informacje o uogólnionych typach w maszynie wirtualnej (216)
• Ćwiczenia (218)

Rozdział 7. Kolekcje (221)

• 7.1. Mechanizmy do zarządzania kolekcjami (222)
• 7.2. Iteratory (225)
• 7.3. Zestawy (226)
• 7.4. Mapy (227)
• 7.5. Inne kolekcje (230)
  • 7.5.1. Właściwości (231)
  • 7.5.2. Zestawy bitów (231)
  • 7.5.3. Zestawy wyliczeniowe i mapy (233)
  • 7.5.4. Stosy, kolejki zwykłe i dwukierunkowe oraz kolejki z priorytetami (234)
  • 7.5.5. Klasa WeakHashMap (235)
• 7.6. Widoki (235)
  • 7.6.1. Zakresy (236)
  • 7.6.2. Widoki puste i typu singleton (236)
  • 7.6.3. Niemodyfikowalne widoki (237)
• Ćwiczenia (238)

Rozdział 8. Strumienie (241)

• 8.1. Od iteratorów do operacji strumieniowych (242)
• 8.2. Tworzenie strumienia (244)
• 8.3. Metody filter, map i flatMap (245)
• 8.4. Wycinanie podstrumieni i łączenie strumieni (246)
• 8.5. Inne przekształcenia strumieni (247)
• 8.6. Proste redukcje (247)
• 8.7. Typ Optional (248)
  • 8.7.1. Jak korzystać z wartości Optional (249)
  • 8.7.2. Jak nie korzystać z wartości Optional (250)
  • 8.7.3. Tworzenie wartości Optional (250)
  • 8.7.4. Łączenie flatMap z funkcjami wartości Optional (250)
• 8.8. Kolekcje wyników (251)
• 8.9. Tworzenie map (252)
• 8.10. Grupowanie i partycjonowanie (254)
• 8.11. Kolektory strumieniowe (255)
• 8.12. Operacje redukcji (256)
• 8.13. Strumienie typów prostych (257)
• 8.14. Strumienie równoległe (259)
• Ćwiczenia (261)

Rozdział 9. Przetwarzanie danych wejściowych i wyjściowych (263)

• 9.1. Strumienie wejściowe i wyjściowe, mechanizmy wczytujące i zapisujące (264)
  • 9.1.1. Pozyskiwanie strumieni (264)
  • 9.1.2. Wczytywanie bajtów (265)
  • 9.1.3. Zapisywanie bajtów (266)
  • 9.1.4. Kodowanie znaków (266)
  • 9.1.5. Wczytywanie danych tekstowych (268)
  • 9.1.6. Generowanie danych tekstowych (270)
  • 9.1.7. Wczytywanie i zapisywanie danych binarnych (271)
  • 9.1.8. Pliki o swobodnym dostępie (272)
  • 9.1.9. Pliki mapowane w pamięci (272)
  • 9.1.10. Blokowanie plików (273)
• 9.2. Ścieżki, pliki i katalogi (273)
  • 9.2.1. Ścieżki (273)
  • 9.2.2. Tworzenie plików i katalogów (275)
  • 9.2.3. Kopiowanie, przenoszenie i usuwanie plików (276)
  • 9.2.4. Odwiedzanie katalogów (276)
  • 9.2.5. System plików ZIP (279)
• 9.3. Połączenia URL (280)
• 9.4. Wyrażenia regularne (281)
  • 9.4.1. Składnia wyrażeń regularnych (281)
  • 9.4.2. Odnajdywanie jednego lub wszystkich dopasowań (285)
  • 9.4.3. Grupy (286)
  • 9.4.4. Usuwanie lub zastępowanie dopasowań (287)
  • 9.4.5. Flagi (288)
• 9.5. Serializacja (288)
  • 9.5.1. Interfejs Serializable (289)
  • 9.5.2. Chwilowe zmienne instancji (290)
  • 9.5.3. Metody readObject i writeObject (291)
  • 9.5.4. Metody readResolve i writeReplace (292)
  • 9.5.5. Wersjonowanie (293)
• Ćwiczenia (294)

Rozdział 10. Programowanie współbieżne (297)

• 10.1. Zadania współbieżne (298)
  • 10.1.1. Uruchamianie zadań (299)
  • 10.1.2. Obiekty Future i Executor (300)
• 10.2. Bezpieczeństwo wątków (302)
  • 10.2.1. Widoczność (302)
  • 10.2.2. Wyścigi (304)
  • 10.2.3. Strategie bezpiecznego korzystania ze współbieżności (306)
  • 10.2.4. Klasy niemodyfikowalne (307)
• 10.3. Algorytmy równoległe (308)
  • 10.3.1. Strumienie równoległe (308)
  • 10.3.2. Równoległe operacje na tablicach (309)
• 10.4. Struktury danych bezpieczne dla wątków (310)
  • 10.4.1. Klasa ConcurrentHashMap (310)
  • 10.4.2. Kolejki blokujące (312)
  • 10.4.3. Inne struktury danych bezpieczne dla wątków (313)
• 10.5. Wartości atomowe (314)
• 10.6. Blokady (316)
  • 10.6.1. Blokady wielowejściowe (316)
  • 10.6.2. Słowo kluczowe synchronized (317)
  • 10.6.3. Oczekiwanie warunkowe (319)
• 10.7. Wątki (321)
  • 10.7.1. Uruchamianie wątku (321)
  • 10.7.2. Przerywanie wątków (322)
  • 10.7.3. Zmienne lokalne w wątku (323)
  • 10.7.4. Dodatkowe właściwości wątku (324)
• 10.8. Obliczenia asynchroniczne (325)
  • 10.8.1. Długie zadania obsługujące interfejs użytkownika (325)
  • 10.8.2. Klasa CompletableFuture (326)
• 10.9. Procesy (329)
  • 10.9.1. Tworzenie procesu (329)
  • 10.9.2. Uruchamianie procesu (331)
• Ćwiczenia (331)

Rozdział 11. Adnotacje (337)

• 11.1. Używanie adnotacji (338)
  • 11.1.1. Elementy adnotacji (339)
  • 11.1.2. Wielokrotne i powtarzane adnotacje (340)
  • 11.1.3. Adnotacje deklaracji (340)
  • 11.1.4. Adnotacje wykorzystania typów (341)
  • 11.1.5. Jawne określanie odbiorców (342)
• 11.2. Definiowanie adnotacji (343)
• 11.3. Adnotacje standardowe (345)
  • 11.3.1. Adnotacje do kompilacji (345)
  • 11.3.2. Adnotacje do zarządzania zasobami (347)
  • 11.3.3. Metaadnotacje (347)
• 11.4. Przetwarzanie adnotacji w kodzie (349)
• 11.5. Przetwarzanie adnotacji w kodzie źródłowym (352)
  • 11.5.1. Przetwarzanie adnotacji (352)
  • 11.5.2. API modelu języka (353)
  • 11.5.3. Wykorzystanie adnotacji do generowania kodu źródłowego (353)
• Ćwiczenia (356)

Rozdział 12. API daty i czasu (357)

• 12.1. Linia czasu (358)
• 12.2. Daty lokalne (360)
• 12.3. Modyfikatory daty (362)
• 12.4. Czas lokalny (363)
• 12.5. Czas strefowy (364)
• 12.6. Formatowanie i przetwarzanie (367)
• 12.7. Współpraca z przestarzałym kodem (370)
• Ćwiczenia (371)

Rozdział 13. Internacjonalizacja (373)

• 13.1. Lokalizacje (374)
  • 13.1.1. Określanie lokalizacji (375)
  • 13.1.2. Domyślna lokalizacja (377)
  • 13.1.3. Nazwy wyświetlane (378)
• 13.2. Formaty liczb (378)
• 13.3. Waluty (379)
• 13.4. Formatowanie czasu i daty (380)
• 13.5. Porównywanie i normalizacja (382)
• 13.6. Formatowanie komunikatów (383)
• 13.7. Pakiety z zasobami (385)
  • 13.7.1. Organizacja pakietów z zasobami (385)
  • 13.7.2. Klasy z pakietami (387)
• 13.8. Kodowanie znaków (388)
• 13.9. Preferencje (389)
• Ćwiczenia (391)

Rozdział 14. Kompilacja i skryptowanie (393)

• 14.1. API kompilatora (394)
  • 14.1.1. Wywołanie kompilatora (394)
  • 14.1.2. Uruchamianie zadania kompilacji (394)
  • 14.1.3. Wczytywanie plików źródłowych z pamięci (395)
  • 14.1.4. Zapisywanie skompilowanego kodu w pamięci (396)
  • 14.1.5. Przechwytywanie komunikatów diagnostycznych (397)
• 14.2. API skryptów (397)
  • 14.2.1. Tworzenie silnika skryptowego (398)
  • 14.2.2. Powiązania (399)
  • 14.2.3. Przekierowanie wejścia i wyjścia (399)
  • 14.2.4. Wywoływanie funkcji i metod skryptowych (400)
  • 14.2.5. Kompilowanie skryptu (401)
• 14.3. Silnik skryptowy Nashorn (401)
  • 14.3.1. Uruchamianie Nashorna z wiersza poleceń (402)
  • 14.3.2. Wywoływanie metod pobierających i ustawiających dane oraz metod przeładowanych (403)
  • 14.3.3. Tworzenie obiektów języka Java (403)
  • 14.3.4. Ciągi znaków w językach JavaScript i Java (404)
  • 14.3.5. Liczby (405)
  • 14.3.6. Praca z tablicami (406)
  • 14.3.7. Listy i mapy (407)
  • 14.3.8. Wyrażenia lambda (407)
  • 14.3.9. Rozszerzanie klas Java i implementowanie interfejsów Java (408)
  • 14.3.10. Wyjątki (409)
• 14.4. Skrypty powłoki z silnikiem Nashorn (410)
  • 14.4.1. Wykonywanie poleceń powłoki (410)
  • 14.4.2. Uzupełnianie ciągów znaków (411)
  • 14.4.3. Wprowadzanie danych do skryptu (412)
• Ćwiczenia (413)

Skorowidz (415)

pokaż cały spis treści

ukryj recenzje