Cay S. Horstmann autor "Java. Podstawy. Wydanie IX" i "Java. Techniki zaawansowane. Wydanie IX" - najpopularniejszych w Polsce podręczników do nauki JavyJava to język, który zrewolucjonizował świat programistów. Jej możliwości zostały docenione przez największe firmy. Dziś Java jest wykorzystywana w najbardziej zaawansowanych projektach. Wszędzie tam, gdzie są wymagane najwyższa wydajność i bezpieczeństwo, nie ma sobie równych! Aktualna wersja tego języka wprowadza wiele nowych konstrukcji i usprawnień — jeżeli chcesz błyskawicznie je poznać, zacznij od tej książki.
Została ona napisana specjalnie z myślą o osobach chcących rozpocząć kodowanie z wykorzystaniem nowości z Javy 8. Jest przeznaczona dla doświadczonych programistów, lecz zawiera też podstawowe informacje na temat technik programowania obiektowego, wyjątków, typów i składni. Dzięki temu możesz błyskawicznie wdrożyć się w nowy język programowania! Natomiast jeśli znasz już Javę, z pewnością zainteresują Cię informacje o wyrażeniach lambda, projekcie Nashorn oraz nowym API do operacji na datach i czasie (JSR 310). Książka ta jest najlepszą lekturą dla wszystkich programistów zainteresowanych językiem Java oraz nowościami w Javie 8!
Jeśli jesteś posiadasz doświadzenie w programowaniu Javy, praktyczne podejście Horstmanna i przykładowe kody pomogą Ci szybko wykorzystać wyrażenia lambda, strumienie i inne usprawnienia wprowadzone zarówno do języka jak i platformy Java. Horstmann omawia wszystko, co powinni wiedzieć deweloperzy na temat nowoczesnej Javy, przedstawiając:
- konkretne i efektywne omówienie wyrażeń lambda, umożliwiające opisywanie działań za pomocą zwięzłej składni;
- dokładne wprowadzenie do nowego API strumieni, które bardzo uelastycznia i zwiększa wydajność pracy z danymi;
- kurs programowania współbieżnego, który zachęca do projektowania programów na poziomie współpracujących zadań, a nie niskopoziomowych wątków i blokad,
- aktualne omówienie nowych bibliotek np. do obsługi daty i czasu,
- inne nowe mechanizmy, które są szczególnie wartościowe dla programistów aplikacji serwerowych lub programistów urządzeń mobilnych.
Rozdziały:
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)
Najniższa cena z 30 dni przed obniżką 51,75zł
|