Java. Przewodnik doświadczonego programisty. Wydanie III Cay S. Horstmann

Dostępność produktu

Produkt nie został jeszcze oceniony pod kątem ułatwień dostępu lub nie podano żadnych informacji o ułatwieniach dostępu lub są one niewystarczające. Prawdopodobnie Wydawca/Dostawca jeszcze nie umożliwił dokonania walidacji produktu lub nie przekazał odpowiednich informacji na temat jego dostępności.

Spis treści książki

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

pokaż cały spis treści

ukryj recenzje