Джава. Руководство опытного разработчика

Java. Przewodnik doświadczonego programisty. Wydanie III

Cay S. Horstmann

Java jest dojrzałym, rozbudowanym, wszechstronnym, a przy tym starannie zaprojektowanym i bezpiecznym językiem programowania. W jego nowej, 17. wersji wprowadzono sporo usprawnień podstawowych elementów języka i interfejsów API. Wiele starych idiomów języka straciło przydatność, a nowe mechanizmy i paradygmaty pozwalają zwiększyć efektywność tworzenia kodu. Zawodowy programista musi dobrze poznać te nowości i nauczyć się z nich korzystać.

Oto zaktualizowane i uzupełnione wydanie zwięzłego wprowadzenia do Javy SE 17, przeznaczonego dla profesjonalnych programistów Javy. Przedstawiono w nim wszystkie istotne zagadnienia, łącznie z takimi koncepcjami jak wyrażenia lambda i strumienie, nowoczesnymi konstrukcjami, jak rekordy i klasy zapieczętowane, a także zaawansowanymi technikami programowania współbieżnego. Książka została pomyślana w taki sposób, aby wszystkie ważne zmiany wprowadzone w najnowszej wersji Javy zostały zaprezentowane w esencjonalnej formie. Informacje uporządkowano tak, aby ułatwić szybki dostęp i łatwe zrozumienie potrzebnego zagadnienia. W przewodniku znalazło się też mnóstwo praktycznych informacji wraz z przykładami kodu, pozwalającymi natychmiast przetestować wszystkie nowości.

W książce między innymi:

• rekordy i klasy zapieczętowane
• programowanie funkcyjne z wyrażeniami lambda
• optymalne zarządzanie danymi
• nowoczesne funkcje biblioteczne i bezpieczne struktury danych
• zmodularyzowane API języka Java
• interfejsy API służące do przetwarzania daty i czasu oraz internacjonalizacji

Java: poznaj najnowsze mechanizmy i paradygmaty!

O autorze:

Cay S. Horstmann jest głównym autorem książek Java. Podstawy. Wydanie IX i Java. Techniki zaawansowane. Wydanie IX - najpopularniejszych w Polsce podręczników do nauki Javy. Cay jest profesorem informatyki na Uniwersytecie Stanowym w San José, ma tytuł Java Champion i często wygłasza odczyty na konferencjach związanych z branżą komputerową.

Spis treści:

Wstęp

Podziękowania

O autorze

1. Podstawowe struktury programistyczne

• 1.1. Nasz pierwszy program

  1.1.1. Analiza programu "Witaj, świecie!"

  1.1.2. Kompilacja i uruchamianie programu w języku Java

  1.1.3. Wywołania metod

  1.1.4. JShell

• 1.2. Typy proste

  1.2.1. Typy całkowite ze znakiem

  1.2.2. Typy zmiennoprzecinkowe

  1.2.3. Typ char

  1.2.4. Typ boolean

• 1.3. Zmienne

  1.3.1. Deklaracje zmiennych

  1.3.2. Identyfikatory

  1.3.3. Inicjalizacja

  1.3.4. Stałe

• 1.4. Działania arytmetyczne

  1.4.1. Przypisanie

  1.4.2. Podstawowa arytmetyka

  1.4.3. Metody matematyczne

  1.4.4. Konwersja typów liczbowych

  1.4.5. Operatory relacji i operatory logiczne

  1.4.6. Duże liczby

• 1.5. Ciągi znaków

  1.5.1. Łączenie ciągów znaków

  1.5.2. Wycinanie ciągów znaków

  1.5.3. Porównywanie ciągów znaków

  1.5.4. Konwersja liczb na znaki i znaków na liczby

  1.5.5. API klasy String

  1.5.6. Kodowanie znaków w języku Java

  1.5.7. Bloki tekstu

• 1.6. Wejście i wyjście

  1.6.1. Wczytywanie danych wejściowych

  1.6.2. Formatowanie generowanych danych

• 1.7. Kontrola przepływu

  1.7.1. Instrukcje warunkowe

  1.7.2. Słowo kluczowe switch

  1.7.3. Pętle

  1.7.4. Przerywanie i kontynuacja

  1.7.5. Zasięg zmiennych lokalnych

• 1.8. Tablice i listy tablic

  1.8.1. Obsługa tablic

  1.8.2. Tworzenie tablicy

  1.8.3. Klasa ArrayList

  1.8.4. Klasy opakowujące typy proste

  1.8.5. Rozszerzona pętla for

  1.8.6. Kopiowanie tablic i obiektów ArrayList

  1.8.7. Algorytmy tablic

  1.8.8. Parametry wiersza poleceń

  1.8.9. Tablice wielowymiarowe

• 1.9. Dekompozycja funkcjonalna

  1.9.1. Deklarowanie i wywoływanie metod statycznych

  1.9.2. Parametry tablicowe i zwracane wartości

  1.9.3. Zmienna liczba parametrów

• Ćwiczenia

2. Programowanie obiektowe

• 2.1. Praca z obiektami

  2.1.1. Metody dostępowe i modyfikujące

  2.1.2. Referencje do obiektu

• 2.2. Implementowanie klas

  2.2.1. Zmienne instancyjne

  2.2.2. Nagłówki metod

  2.2.3. Treści metod

  2.2.4. Wywołania metod instancyjnych

  2.2.5. Referencja this

  2.2.6. Wywołanie przez wartość

• 2.3. Tworzenie obiektów

  2.3.1. Implementacja konstruktorów

  2.3.2. Przeciążanie

  2.3.3. Wywoływanie jednego konstruktora z innego

  2.3.4. Domyślna inicjalizacja

  2.3.5. Inicjalizacja zmiennych instancyjnych

  2.3.6. Zmienne instancyjne z modyfikatorem final

  2.3.7. Konstruktor bez parametrów

• 2.4. Rekordy

  2.4.1. Koncepcja rekordu

  2.4.2. Konstruktory: kanoniczny, niestandardowy i kompaktowy

• 2.5. Statyczne zmienne i metody

  2.5.1. Zmienne statyczne

  2.5.2. Stałe statyczne

  2.5.3. Statyczne bloki inicjalizacyjne

  2.5.4. Metody statyczne

  2.5.5. Metody wytwórcze

• 2.6. Pakiety

  2.6.1. Deklarowanie pakietów

  2.6.2. Polecenie jar

  2.6.3. Ścieżka przeszukiwań dla klas

  2.6.4. Dostęp do pakietu

  2.6.5. Importowanie klas

  2.6.6. Import metod statycznych

• 2.7. Klasy zagnieżdżone

  2.7.1. Statyczne klasy zagnieżdżone

  2.7.2. Klasy wewnętrzne

  2.7.3. Specjalne reguły składni dla klas wewnętrznych

• 2.8. Komentarze do dokumentacji

  2.8.1. Wstawianie komentarzy

  2.8.2. Komentarze klasy

  2.8.3. Komentarze metod

  2.8.4. Komentarze zmiennych

  2.8.5. Ogólne komentarze

  2.8.6. Odnośniki

  2.8.7. Opisy pakietów, modułów i ogólne

  2.8.8. Wycinanie komentarzy

• Ćwiczenia

3. Interfejsy i wyrażenia lambda

• 3.1. Interfejsy

  3.1.1. Korzystanie z interfejsów

  3.1.2. Deklarowanie interfejsu

  3.1.3. Implementowanie interfejsu

  3.1.4. Konwersja do typu interfejsu

  3.1.5. Rzutowanie i operator instanceof

  3.1.6. Forma operatora instanceof z "dopasowywaniem wzorca"

  3.1.7. Rozszerzanie interfejsów

  3.1.8. Implementacja wielu interfejsów

  3.1.9. Stałe

• 3.2. Metody statyczne, domyślne i prywatne

  3.2.1. Metody statyczne

  3.2.2. Metody domyślne

  3.2.3. Rozstrzyganie konfliktów metod domyślnych

  3.2.4. Metody prywatne

• 3.3. Przykłady interfejsów

  3.3.1. Interfejs Comparable

  3.3.2. Interfejs Comparator

  3.3.3. Interfejs Runnable

  3.3.4. Wywołania zwrotne interfejsu użytkownika

• 3.4. Wyrażenia lambda

  3.4.1. Składnia wyrażeń lambda

  3.4.2. Interfejsy funkcyjne

• 3.5. Referencje do metod i konstruktora

  3.5.1. Referencje do metod

  3.5.2. Referencje konstruktora

• 3.6. Przetwarzanie wyrażeń lambda

  3.6.1. Implementacja odroczonego wykonania

  3.6.2. Wybór interfejsu funkcyjnego

  3.6.3. Implementowanie własnych interfejsów funkcyjnych

• 3.7. Wyrażenia lambda i zasięg zmiennych

  3.7.1. Zasięg zmiennej lambda

  3.7.2. Dostęp do zmiennych zewnętrznych

• 3.8. Funkcje wyższych rzędów

  3.8.1. Metody zwracające funkcje

  3.8.2. Metody modyfikujące funkcje

  3.8.3. Metody interfejsu Comparator

• 3.9. Klasy lokalne i anonimowe

  3.9.1. Klasy lokalne

  3.9.2. Klasy anonimowe

• Ćwiczenia

4. Dziedziczenie i mechanizm refleksji

• 4.1. Rozszerzanie klas

  4.1.1. Klasy nadrzędne i podrzędne

  4.1.2. Definiowanie i dziedziczenie metod klas podrzędnych

  4.1.3. Przesłanianie metod

  4.1.4. Tworzenie klasy podrzędnej

  4.1.5. Przypisania klas nadrzędnych

  4.1.6. Rzutowanie

  4.1.7. Anonimowe klasy podrzędne

  4.1.8. Wywołania metod z super

• 4.2. Hierarchie dziedziczenia

  4.2.1. Metody i klasy z modyfikatorem final

  4.2.2. Abstrakcyjne metody i klasy

  4.2.3. Ograniczony dostęp

  4.2.4. Typy zapieczętowane

  4.2.5. Dziedziczenie i metody domyślne

• 4.3. Object - najwyższa klasa nadrzędna

  4.3.1. Metoda toString

  4.3.2. Metoda equals

  4.3.3. Metoda hashCode

  4.3.4. Klonowanie obiektów

• 4.4. Wyliczenia

  4.4.1. Sposoby wyliczania

  4.4.2. Konstruktory, metody i pola

  4.4.3. Zawartość elementów

  4.4.4. Elementy statyczne

  4.4.5. Wyrażenia switch ze stałymi wyliczeniowymi

• 4.5. Informacje o typie i zasobach w czasie działania programu

  4.5.1. Klasa Class

  4.5.2. Wczytywanie zasobów

  4.5.3. Programy wczytujące klasy

  4.5.4. Kontekstowy program wczytujący klasy

  4.5.5. Programy do ładowania usług

• 4.6. Refleksje

  4.6.1. Wyliczanie elementów klasy

  4.6.2. Kontrolowanie obiektów

  4.6.3. Wywoływanie metod

  4.6.4. Tworzenie obiektów

  4.6.5. JavaBeans

  4.6.6. Praca z tablicami

  4.6.7. Klasa Proxy

• Ćwiczenia

5. Wyjątki, asercje i logi

• 5.1. Obsługa wyjątków

  5.1.1. Wyrzucanie wyjątków

  5.1.2. Hierarchia wyjątków

  5.1.3. Deklarowanie wyjątków kontrolowanych

  5.1.4. Przechwytywanie wyjątków

  5.1.5. Wyrażenie try z określeniem zasobów

  5.1.6. Klauzula finally

  5.1.7. Ponowne wyrzucanie wyjątków i łączenie ich w łańcuchy

  5.1.8. Nieprzechwycone wyjątki i ślad stosu wywołań

  5.1.9. Metody API pozwalające wyrzucać wyjątki

• 5.2. Asercje

  5.2.1. Użycie asercji

  5.2.2. Włączanie i wyłączanie asercji

• 5.3. Rejestrowanie danych

  5.3.1. Czy w Javie warto korzystać z frameworka rejestrowania danych?

  5.3.2. ABC rejestrowania danych

  5.3.3. Interfejs Platform Logging API

  5.3.4. Konfiguracja mechanizmów rejestrowania danych

  5.3.5. Programy obsługujące rejestrowanie danych

  5.3.6. Filtry i formaty

• Ćwiczenia

6. Programowanie uogólnione

• 6.1. Klasy uogólnione
• 6.2. Metody uogólnione
• 6.3. Ograniczenia typów
• 6.4. Zmienność typów i symbole wieloznaczne

  6.4.1. Symbole wieloznaczne w typach podrzędnych

  6.4.2. Symbole wieloznaczne typów nadrzędnych

  6.4.3. Symbole wieloznaczne ze zmiennymi typami

  6.4.4. Nieograniczone symbole wieloznaczne

  6.4.5. Przechwytywanie symboli wieloznacznych

• 6.5. Uogólnienia w maszynie wirtualnej Javy

  6.5.1. Wymazywanie typów

  6.5.2. Wprowadzanie rzutowania

  6.5.3. Metody pomostowe

• 6.6. Ograniczenia uogólnień

  6.6.1. Brak typów prostych

  6.6.2. W czasie działania kodu wszystkie typy są surowe

  6.6.3. Nie możesz tworzyć instancji zmiennych opisujących typy

  6.6.4. Nie możesz tworzyć tablic z parametryzowanym typem

  6.6.5. Zmienne opisujące typ klasy nie są poprawne w kontekście statycznym

  6.6.6. Metody nie mogą wywoływać konfliktów po wymazywaniu typów

  6.6.7. Wyjątki i uogólnienia

• 6.7. Refleksje i uogólnienia

  6.7.1. Klasa Class<T>

  6.7.2. Informacje o uogólnionych typach w maszynie wirtualnej

• Ćwiczenia

7. Kolekcje

• 7.1. Mechanizmy do zarządzania kolekcjami
• 7.2. Iteratory
• 7.3. Zestawy
• 7.4. Mapy
• 7.5. Inne kolekcje

  7.5.1. Właściwości

  7.5.2. Zestawy bitów

  7.5.3. Zestawy wyliczeniowe i mapy

  7.5.4. Stosy, kolejki zwykłe i dwukierunkowe oraz kolejki z priorytetami

  7.5.5. Klasa WeakHashMap

• 7.6. Widoki

  7.6.1. Małe kolekcje

  7.6.2. Zakresy

  7.6.3. Niemodyfikowalne widoki

• Ćwiczenia

8. Strumienie

• 8.1. Od iteratorów do operacji strumieniowych
• 8.2. Tworzenie strumienia
• 8.3. Metody filter, map i flatMap
• 8.4. Wycinanie podstrumieni i łączenie strumieni
• 8.5. Inne przekształcenia strumieni
• 8.6. Proste redukcje
• 8.7. Typ Optional

  8.7.1. Tworzenie alternatywnej wartości

  8.7.2. Wykorzystywanie wartości tylko wtedy, gdy jest obecna

  8.7.3. Przetwarzanie potokowe wartości typu Optional

  8.7.4. Jak nie korzystać z wartości Optional

  8.7.5. Tworzenie wartości Optional

  8.7.6. Łączenie flatMap z funkcjami wartości Optional

  8.7.7. Zamiana Optional w Stream

• 8.8. Kolekcje wyników
• 8.9. Tworzenie map
• 8.10. Grupowanie i partycjonowanie
• 8.11. Kolektory strumieniowe
• 8.12. Operacje redukcji
• 8.13. Strumienie typów prostych
• 8.14. Strumienie równoległe
• Ćwiczenia

9. Przetwarzanie danych wejściowych i wyjściowych

• 9.1. Strumienie wejściowe i wyjściowe, mechanizmy wczytujące i zapisujące

  9.1.1. Pozyskiwanie strumieni

  9.1.2. Wczytywanie bajtów

  9.1.3. Zapisywanie bajtów

  9.1.4. Kodowanie znaków

  9.1.5. Wczytywanie danych tekstowych

  9.1.6. Generowanie danych tekstowych

  9.1.7. Wczytywanie i zapisywanie danych binarnych

  9.1.8. Pliki o swobodnym dostępie

  9.1.9. Pliki mapowane w pamięci

  9.1.10. Blokowanie plików

• 9.2. Ścieżki, pliki i katalogi

  9.2.1. Ścieżki

  9.2.2. Tworzenie plików i katalogów

  9.2.3. Kopiowanie, przenoszenie i usuwanie plików

  9.2.4. Odwiedzanie katalogów

  9.2.5. System plików ZIP

• 9.3. Połączenia HTTP

  9.3.1. Klasy URLConnection i HttpURLConnection

  9.3.2. API klienta HTTP

• 9.4. Wyrażenia regularne

  9.4.1. Składnia wyrażeń regularnych

  9.4.2. Testowanie dopasowania

  9.4.3. Odnajdywanie wszystkich dopasowań

  9.4.4. Grupy

  9.4.5. Dzielenie za pomocą znaczników

  9.4.6. Zastępowanie dopasowań

  9.4.7. Flagi

• 9.5. Serializacja

  9.5.1. Interfejs Serializable

  9.5.2. Chwilowe zmienne instancyjne

  9.5.3. Metody readObject i writeObject

  9.5.4. Metody readExternal i writeExternal

  9.5.5. Metody readResolve i writeReplace

  9.5.6. Wersjonowanie

  9.5.7. Deserializacja i bezpieczeństwo

• Ćwiczenia

10. Programowanie współbieżne

• 10.1. Zadania współbieżne

  10.1.1. Uruchamianie zadań

  10.1.2. Obiekty Future

• 10.2. Obliczenia asynchroniczne

  10.2.1. Klasa CompletableFuture

  10.2.2. Tworzenie obiektów typu CompletableFuture

  10.2.3. Długie zadania obsługujące interfejs użytkownika

• 10.3. Bezpieczeństwo wątków

  10.3.1. Widoczność

  10.3.2. Wyścigi

  10.3.3. Strategie bezpiecznego korzystania ze współbieżności

  10.3.4. Klasy niemodyfikowalne

• 10.4. Algorytmy równoległe

  10.4.1. Strumienie równoległe

  10.4.2. Równoległe operacje na tablicach

• 10.5. Struktury danych bezpieczne dla wątków

  10.5.1. Klasa ConcurrentHashMap

  10.5.2. Kolejki blokujące

  10.5.3. Inne struktury danych bezpieczne dla wątków

• 10.6. Atomowe liczniki i akumulatory
• 10.7. Blokady i warunki

  10.7.1. Blokady

  10.7.2. Słowo kluczowe synchronized

  10.7.3. Oczekiwanie warunkowe

• 10.8. Wątki

  10.8.1. Uruchamianie wątku

  10.8.2. Przerywanie wątków

  10.8.3. Zmienne lokalne w wątku

  10.8.4. Dodatkowe właściwości wątku

• 10.9. Procesy

  10.9.1. Tworzenie procesu

  10.9.2. Uruchamianie procesu

  10.9.3. Uchwyty procesów

• Ćwiczenia

11. Adnotacje

• 11.1. Używanie adnotacji

  11.1.1. Elementy adnotacji

  11.1.2. Wielokrotne i powtarzane adnotacje

  11.1.3. Adnotacje deklaracji

  11.1.4. Adnotacje wykorzystania typów

  11.1.5. Jawne określanie odbiorców

• 11.2. Definiowanie adnotacji
• 11.3. Adnotacje standardowe

  11.3.1. Adnotacje do kompilacji

  11.3.2. Metaadnotacje

• 11.4. Przetwarzanie adnotacji w kodzie
• 11.5. Przetwarzanie adnotacji w kodzie źródłowym

  11.5.1. Przetwarzanie adnotacji

  11.5.2. API modelu języka

  11.5.3. Wykorzystanie adnotacji do generowania kodu źródłowego

• Ćwiczenia

12. API daty i czasu

• 12.1. Linia czasu
• 12.2. Daty lokalne
• 12.3. Modyfikatory daty
• 12.4. Czas lokalny
• 12.5. Czas strefowy
• 12.6. Formatowanie i przetwarzanie
• 12.7. Współpraca z przestarzałym kodem
• Ćwiczenia

13. Internacjonalizacja

• 13.1. Lokalizacje

  13.1.1. Określanie lokalizacji

  13.1.2. Domyślna lokalizacja

  13.1.3. Nazwy wyświetlane

• 13.2. Formaty liczb
• 13.3. Waluty
• 13.4. Formatowanie czasu i daty
• 13.5. Porównywanie i normalizacja
• 13.6. Formatowanie komunikatów
• 13.7. Pakiety z zasobami

  13.7.1. Organizacja pakietów z zasobami

  13.7.2. Klasy z pakietami

• 13.8. Kodowanie znaków
• 13.9. Preferencje
• Ćwiczenia

14. Kompilacja i skryptowanie

• 14.1. API kompilatora

  14.1.1. Wywołanie kompilatora

  14.1.2. Uruchamianie zadania kompilacji

  14.1.3. Przechwytywanie komunikatów diagnostycznych

  14.1.4. Wczytywanie plików źródłowych z pamięci

  14.1.5. Zapisywanie skompilowanego kodu w pamięci

• 14.2. API skryptów

  14.2.1. Tworzenie silnika skryptowego

  14.2.2. Uruchamianie skryptów za pomocą metody eval

  14.2.3. Powiązania

  14.2.4. Przekierowanie wejścia i wyjścia

  14.2.5. Wywoływanie funkcji i metod skryptowych

  14.2.6. Kompilowanie skryptu

• Ćwiczenia

15. System modułów na platformie Java

• 15.1. Koncepcja modułu
• 15.2. Nazywanie modułów
• 15.3. Modularny program "Witaj, świecie!"
• 15.4. Dołączanie modułów
• 15.5. Eksportowanie pakietów
• 15.6. Moduły i dostęp przez refleksje
• 15.7. Modularne pliki JAR
• 15.8. Moduły automatyczne
• 15.9. Moduł nienazwany
• 15.10. Flagi wiersza poleceń dla migracji
• 15.11. Wymagania przechodnie i statyczne
• 15.12. Wybiórcze eksportowanie i otwieranie
• 15.13. Wczytywanie usługi
• 15.14. Narzędzia do pracy z modułami
• Ćwiczenia