Java. Podstawy. Wydanie XIII Cay S. Horstmann

Dostępność produktu

Produkt został zweryfikowany pod kątem ułatwień dostępu więcej przeczytasz w deklaracji dostępności.

Spis treści książki

Wstęp
• Do Czytelnika
• O książce
• Konwencje typograficzne
• Przykłady kodu

Podziękowania

Rozdział 1. Wprowadzenie do Javy

• 1.1. Java jako platforma programistyczna
• 1.2. Słowa klucze białej księgi Javy
  • 1.2.1. Prostota
  • 1.2.2. Obiektowość
  • 1.2.3. Sieciowość
  • 1.2.4. Niezawodność
  • 1.2.5. Bezpieczeństwo
  • 1.2.6. Niezależność od architektury
  • 1.2.7. Przenośność
  • 1.2.8. Interpretacja
  • 1.2.9. Wysoka wydajność
  • 1.2.10. Wielowątkowość
  • 1.2.11. Dynamiczność
• 1.3. Aplety Javy i internet
• 1.4. Krótka historia Javy
• 1.5. Główne nieporozumienia dotyczące Javy

Rozdział 2. Środowisko programistyczne Javy

• 2.1. Instalacja oprogramowania Java Development Kit
  • 2.1.1. Pobieranie pakietu JDK
  • 2.1.2. Instalacja pakietu JDK
  • 2.1.3. Instalacja plików źródłowych i dokumentacji
• 2.2. Używanie narzędzi wiersza poleceń
• 2.3. Praca w zintegrowanym środowisku programistycznym
• 2.4. JShell

Rozdział 3. Podstawowe elementy języka Java

• 3.1. Prosty program w Javie
• 3.2. Komentarze
• 3.3. Typy danych
  • 3.3.1. Typy całkowite
  • 3.3.2. Typy zmiennoprzecinkowe
  • 3.3.3. Typ char
  • 3.3.4. Unicode i typ char
  • 3.3.5. Typ boolean
• 3.4. Zmienne i stałe
  • 3.4.1. Deklarowanie zmiennych
  • 3.4.2. Inicjalizacja zmiennych
  • 3.4.3. Stałe
  • 3.4.4. Typ wyliczeniowy
• 3.5. Operatory
  • 3.5.1. Operatory arytmetyczne
  • 3.5.2. Funkcje i stałe matematyczne
  • 3.5.3. Konwersja typów numerycznych
  • 3.5.4. Rzutowanie
  • 3.5.5. Przypisanie
  • 3.5.6. Operatory inkrementacji i dekrementacji
  • 3.5.7. Operatory relacyjne i logiczne
  • 3.5.8. Operator warunkowy
  • 3.5.9. Wyrażenia switch
  • 3.5.10. Operatory bitowe
  • 3.5.11. Nawiasy i priorytety operatorów
• 3.6. Łańcuchy
  • 3.6.1. Konkatenacja
  • 3.6.2. Dzielenie łańcuchów
  • 3.6.3. Indeksy i podłańcuchy
  • 3.6.4. Łańcuchów nie można modyfikować
  • 3.6.5. Porównywanie łańcuchów
  • 3.6.6. Łańcuchy puste i łańcuchy null
  • 3.6.7. API String
  • 3.6.8. Dokumentacja API w internecie
  • 3.6.9. Składanie łańcuchów
  • 3.6.10. Bloki tekstowe
• 3.7. Wejście i wyjście
  • 3.7.1. Odbieranie danych wejściowych
  • 3.7.2. Formatowanie danych wyjściowych
  • 3.7.3. Zapis i odczyt plików
• 3.8. Sterowanie wykonywaniem programu
  • 3.8.1. Zasięg blokowy
  • 3.8.2. Instrukcje warunkowe
  • 3.8.3. Pętle
  • 3.8.4. Pętle o określonej liczbie powtórzeń
  • 3.8.5. Wybór wielokierunkowy - instrukcja switch
  • 3.8.6. Instrukcje przerywające przepływ sterowania
• 3.9. Wielkie liczby
• 3.10. Tablice
  • 3.10.1. Deklarowanie tablic
  • 3.10.2. Dostęp do elementów tablicy
  • 3.10.3. Pętla typu for each
  • 3.10.4. Kopiowanie tablicy
  • 3.10.5. Argumenty wiersza poleceń
  • 3.10.6. Sortowanie tablicy
  • 3.10.7. Tablice wielowymiarowe
  • 3.10.8. Tablice postrzępione

Rozdział 4. Obiekty i klasy

• 4.1. Wstęp do programowania obiektowego
  • 4.1.1. Klasy
  • 4.1.2. Obiekty
  • 4.1.3. Identyfikacja klas
  • 4.1.4. Relacje między klasami
• 4.2. Używanie klas predefiniowanych
  • 4.2.1. Obiekty i zmienne obiektów
  • 4.2.2. Klasa LocalDate
  • 4.2.3. Metody udostępniające i zmieniające wartość elementu
• 4.3. Definiowanie własnych klas
  • 4.3.1. Klasa Employee
  • 4.3.2. Używanie wielu plików źródłowych
  • 4.3.3. Analiza klasy Employee
  • 4.3.4. Pierwsze kroki w tworzeniu konstruktorów
  • 4.3.5. Deklarowanie zmiennych lokalnych za pomocą słowa kluczowego var
  • 4.3.6. Praca z referencjami null
  • 4.3.7. Parametry jawne i niejawne
  • 4.3.8. Korzyści z hermetyzacji
  • 4.3.9. Przywileje klasowe
  • 4.3.10. Metody prywatne
  • 4.3.11. Stałe jako pola klasy
• 4.4. Pola i metody statyczne
  • 4.4.1. Pola statyczne
  • 4.4.2. Stałe statyczne
  • 4.4.3. Metody statyczne
  • 4.4.4. Metody fabryczne
  • 4.4.5. Metoda main
• 4.5. Parametry metod
• 4.6. Konstruowanie obiektów
  • 4.6.1. Przeciążanie
  • 4.6.2. Domyślna inicjalizacja pól
  • 4.6.3. Konstruktor bezargumentowy
  • 4.6.4. Jawna inicjalizacja pól
  • 4.6.5. Nazywanie parametrów
  • 4.6.6. Wywoływanie innego konstruktora
  • 4.6.7. Bloki inicjalizujące
  • 4.6.8. Niszczenie obiektów i metoda finalize
• 4.7. Rekordy
  • 4.7.1. Koncepcja rekordu
  • 4.7.2. Konstruktory: kanoniczny, niestandardowy i kompaktowy
• 4.8. Pakiety
  • 4.8.1. Nazwy pakietów
  • 4.8.2. Importowanie klas
  • 4.8.3. Importowanie statyczne
  • 4.8.4. Dodawanie klasy do pakietu
  • 4.8.5. Dostęp do pakietu
  • 4.8.6. Ścieżka klas
  • 4.8.7. Ustawianie ścieżki klas
• 4.9. Pliki JAR
  • 4.9.1. Tworzenie plików JAR
  • 4.9.2. Manifest
  • 4.9.3. Wykonywalne pliki JAR
  • 4.9.4. Pliki JAR z wieloma wersjami klas
  • 4.9.5. Kilka uwag na temat opcji wiersza poleceń
• 4.10. Komentarze dokumentacyjne
  • 4.10.1. Wstawianie komentarzy
  • 4.10.2. Komentarze do klas
  • 4.10.3. Komentarze do metod
  • 4.10.4. Komentarze do pól
  • 4.10.5. Komentarze do pakietów
  • 4.10.6. Kod HTML
  • 4.10.7. Łącza
  • 4.10.8. Komentarze ogólne
  • 4.10.9. Fragmenty kodu
  • 4.10.10. Pobieranie komentarzy
• 4.11. Porady dotyczące projektowania klas

Rozdział 5. Dziedziczenie

• 5.1. Klasy, nadklasy i podklasy
  • 5.1.1. Definiowanie podklas
  • 5.1.2. Przesłanianie metod
  • 5.1.3. Konstruktory podklas
  • 5.1.4. Hierarchia dziedziczenia
  • 5.1.5. Polimorfizm
  • 5.1.6. Zasady wywoływania metod
  • 5.1.7. Wyłączanie dziedziczenia - klasy i metody finalne
  • 5.1.8. Rzutowanie
  • 5.1.9. Operator instanceof i dopasowywanie wzorców
  • 5.1.10. Ograniczanie dostępu
• 5.2. Kosmiczna klasa wszystkich klas - Object
  • 5.2.1. Zmienne typu Object
  • 5.2.2. Metoda equals
  • 5.2.3. Porównywanie a dziedziczenie
  • 5.2.4. Metoda hashCode
  • 5.2.5. Metoda toString
• 5.3. Generyczne listy tablicowe
  • 5.3.1. Deklarowanie list tablicowych
  • 5.3.2. Dostęp do elementów listy tablicowej
  • 5.3.3. Zgodność pomiędzy typowanymi a surowymi listami tablicowymi
• 5.4. Opakowania obiektów i automatyczne pakowanie
• 5.5. Metody ze zmienną liczbą argumentów
• 5.6. Klasy abstrakcyjne
• 5.7. Klasy wyliczeniowe
• 5.8. Klasy zapieczętowane
• 5.9. Dopasowywanie do wzorca
  • 5.9.1. Obsługa wartości null
  • 5.9.2. Strażnicy
  • 5.9.3. Kompletność
  • 5.9.4. Dominacja
  • 5.9.5. Wzorce i stałe
  • 5.9.6. Zasięg zmiennych i przekazywanie sterowania w dół
• 5.10. Refleksja
  • 5.10.1. Klasa Class
  • 5.10.2. Podstawy deklarowania wyjątków
  • 5.10.3. Zasoby
  • 5.10.4. Zastosowanie refleksji w analizie funkcjonalności klasy
  • 5.10.5. Refleksja w analizie obiektów w czasie działania programu
  • 5.10.6. Zastosowanie refleksji w generycznym kodzie tablicowym
  • 5.10.7. Wywoływanie dowolnych metod i konstruktorów
• 5.11. Porady projektowe dotyczące dziedziczenia

Rozdział 6. Interfejsy, wyrażenia lambda i klasy wewnętrzne

• 6.1. Interfejsy
  • 6.1.1. Koncepcja interfejsu
  • 6.1.2. Własności interfejsów
  • 6.1.3. Interfejsy a klasy abstrakcyjne
  • 6.1.4. Metody statyczne i prywatne
  • 6.1.5. Metody domyślne
  • 6.1.6. Wybieranie między metodami domyślnymi
  • 6.1.7. Interfejsy i wywołania zwrotne
  • 6.1.8. Interfejs Comparator
  • 6.1.9. Klonowanie obiektów
• 6.2. Wyrażenia lambda
  • 6.2.1. Po co w ogóle są lambdy?
  • 6.2.2. Składnia wyrażeń lambda
  • 6.2.3. Interfejsy funkcyjne
  • 6.2.4. Typy funkcji
  • 6.2.5. Referencje do metod
  • 6.2.6. Referencje do konstruktorów
  • 6.2.7. Zakres dostępności zmiennych
  • 6.2.8. Przetwarzanie wyrażeń lambda
  • 6.2.9. Tworzenie komparatorów
• 6.3. Klasy wewnętrzne
  • 6.3.1. Dostęp do stanu obiektu w klasie wewnętrznej
  • 6.3.2. Specjalne reguły składniowe dotyczące klas wewnętrznych
  • 6.3.3. Czy klasy wewnętrzne są potrzebne i bezpieczne?
  • 6.3.4. Lokalne klasy wewnętrzne
  • 6.3.5. Dostęp do zmiennych finalnych z metod zewnętrznych
  • 6.3.6. Anonimowe klasy wewnętrzne
  • 6.3.7. Klasy statyczne
• 6.4. Moduły ładowania usług
• 6.5. Klasy pośredniczące
  • 6.5.1. Kiedy używać klas pośredniczących?
  • 6.5.2. Tworzenie obiektów pośredniczących
  • 6.5.3. Właściwości klas pośredniczących

Rozdział 7. Wyjątki, asercje i dzienniki

• 7.1. Obsługa błędów
  • 7.1.1. Klasyfikacja wyjątków
  • 7.1.2. Deklarowanie wyjątków kontrolowanych
  • 7.1.3. Zgłaszanie wyjątków
  • 7.1.4. Tworzenie klas wyjątków
• 7.2. Przechwytywanie wyjątków
  • 7.2.1. Przechwytywanie wyjątku
  • 7.2.2. Przechwytywanie wielu typów wyjątków
  • 7.2.3. Powtórne generowanie wyjątków i budowanie łańcuchów wyjątków
  • 7.2.4. Klauzula finally
  • 7.2.5. Instrukcja try z zasobami
  • 7.2.6. Analiza danych ze stosu wywołań
• 7.3. Wskazówki dotyczące stosowania wyjątków
• 7.4. Asercje
  • 7.4.1. Koncepcja asercji
  • 7.4.2. Włączanie i wyłączanie asercji
  • 7.4.3. Zastosowanie asercji do sprawdzania parametrów
  • 7.4.4. Zastosowanie asercji do dokumentowania założeń
• 7.5. Dzienniki
  • 7.5.1. Czy należy używać systemu dzienników Javy?
  • 7.5.2. Podstawy pracy z dziennikami
  • 7.5.3. API rejestrowania platformy
  • 7.5.4. Konfiguracja rejestrowania w dzienniku
  • 7.5.5. Handlery dzienników
  • 7.5.6. Filtry i formatery
  • 7.5.7. Przepis na dziennik
• 7.6. Wskazówki dotyczące debugowania

Rozdział 8. Programowanie generyczne

• 8.1. Dlaczego programowanie generyczne?
  • 8.1.1. Zalety parametrów typów
  • 8.1.2. Dla kogo programowanie generyczne?
• 8.2. Definicja prostej klasy generycznej
• 8.3. Metody generyczne
• 8.4. Ograniczenia zmiennych typowych
• 8.5. Kod generyczny a maszyna wirtualna
  • 8.5.1. Wymazywanie typów
  • 8.5.2. Translacja wyrażeń generycznych
  • 8.5.3. Translacja metod generycznych
  • 8.5.4. Używanie starego kodu
  • 8.5.5. Generyczne wzorce rekordów
• 8.6. Zasady dziedziczenia dla typów generycznych
• 8.7. Typy wieloznaczne
  • 8.7.1. Koncepcja typu wieloznacznego
  • 8.7.2. Ograniczenia nadtypów typów wieloznacznych
  • 8.7.3. Typy wieloznaczne bez ograniczeń
  • 8.7.4. Chwytanie typu wieloznacznego
• 8.8. Ograniczenia i braki
  • 8.8.1. Nie można podawać typów prostych jako parametrów typowych
  • 8.8.2. Sprawdzanie typów w czasie działania programu jest możliwe tylko dla typów surowych
  • 8.8.3. Nie można tworzyć tablic typów generycznych
  • 8.8.4. Ostrzeżenia dotyczące zmiennej liczby argumentów
  • 8.8.5. Generyczne parametry zmienne nie rozkładają tablic typów podstawowych
  • 8.8.6. Nie wolno tworzyć egzemplarzy zmiennych typowych
  • 8.8.7. Nie można utworzyć egzemplarza generycznej tablicy
  • 8.8.8. Zmiennych typowych nie można używać w statycznych kontekstach klas generycznych
  • 8.8.9. Obiektów klasy generycznej nie można zgłaszać ani przechwytywać
  • 8.8.10. Można wyłączyć sprawdzanie wyjątków kontrolowanych
  • 8.8.11. Uważaj na konflikty, które mogą powstać po wymazaniu typów
  • 8.8.12. Dedukcja typów w generycznych wzorcach rekordów jest ograniczona
• 8.9. Refleksja a typy generyczne
  • 8.9.1. Generyczna klasa Class
  • 8.9.2. Zastosowanie parametrów Class<T> do dopasowywania typów
  • 8.9.3. Informacje o typach generycznych w maszynie wirtualnej
  • 8.9.4. Literały typowe

Rozdział 9. Kolekcje

• 9.1. Architektura kolekcji Javy
  • 9.1.1. Oddzielenie warstwy interfejsów od warstwy klas konkretnych
  • 9.1.2. Interfejs Collection
  • 9.1.3. Iteratory
  • 9.1.4. Generyczne metody użytkowe
• 9.2. Interfejsy w systemie kolekcji Javy
• 9.3. Konkretne klasy kolekcyjne
  • 9.3.1. Listy powiązane
  • 9.3.2. Listy tablicowe
  • 9.3.3. Zbiór HashSet
  • 9.3.4. Zbiór TreeSet
  • 9.3.5. Kolejki Queue i Deque
  • 9.3.6. Kolejki priorytetowe
• 9.4. Słowniki
  • 9.4.1. Podstawowe operacje słownikowe
  • 9.4.2. Modyfikowanie wpisów w słowniku
  • 9.4.3. Widoki słowników
  • 9.4.4. Klasa WeakHashMap
  • 9.4.5. Klasy LinkedHashSet i LinkedHashMap
  • 9.4.6. Klasy EnumSet i EnumMap
  • 9.4.7. Klasa IdentityHashMap
• 9.5. Kopie i widoki
  • 9.5.1. Małe kolekcje
  • 9.5.2. Niemodyfikowalne kopie i widoki
  • 9.5.3. Przedziały
  • 9.5.4. Zbiory ze słowników wartości logicznych
  • 9.5.5. Widoki odwrócone
  • 9.5.6. Widoki kontrolowane
  • 9.5.7. Widoki synchronizowane
  • 9.5.8. Uwagi dotyczące operacji opcjonalnych
• 9.6. Algorytmy
  • 9.6.1. Dlaczego algorytmy generyczne?
  • 9.6.2. Sortowanie i tasowanie
  • 9.6.3. Wyszukiwanie binarne
  • 9.6.4. Proste algorytmy
  • 9.6.5. Operacje zbiorowe
  • 9.6.6. Konwersja pomiędzy kolekcjami a tablicami
  • 9.6.7. Pisanie własnych algorytmów
• 9.7. Stare kolekcje
  • 9.7.1. Klasa Hashtable
  • 9.7.2. Wyliczenia
  • 9.7.3. Słowniki własności
  • 9.7.4. Właściwości systemowe
  • 9.7.5. Stosy
  • 9.7.6. Zbiory bitów

Rozdział 10. Współbieżność

• 10.1. Uruchamianie wątków
• 10.2. Stany wątków
  • 10.2.1. Wątki tworzone za pomocą operatora new
  • 10.2.2. Wątki wykonywalne
  • 10.2.3. Wątki BLOCKED i WAITING
  • 10.2.4. Zamykanie wątków
• 10.3. Własności wątków
  • 10.3.1. Wątki wirtualne
  • 10.3.2. Przerywanie wątków
  • 10.3.3. Wątki demony
  • 10.3.4. Nazwy i identyfikatory wątków
  • 10.3.5. Procedury obsługi nieprzechwyconych wyjątków
  • 10.3.6. Priorytety wątków
  • 10.3.7. Fabryki i konstruktory wątków
• 10.4. Koordynacja zadań
  • 10.4.1. Interfejsy Callable i Future
  • 10.4.2. Klasa Executors
  • 10.4.3. Wywoływanie grup zadań
  • 10.4.4. Zmienne lokalne wątków
  • 10.4.5. Metoda rozgałęzienie-złączenie
• 10.5. Synchronizacja
  • 10.5.1. Przykład sytuacji powodującej wyścig
  • 10.5.2. Wyścigi
  • 10.5.3. Obiekty klasy Lock
  • 10.5.4. Warunki
  • 10.5.5. Zakleszczenia
  • 10.5.6. Słowo kluczowe synchronized
  • 10.5.7. Bloki synchronizowane
  • 10.5.8. Monitor
  • 10.5.9. Pola ulotne
  • 10.5.10. Pola finalne
  • 10.5.11. Zmienne atomowe
  • 10.5.12. Inicjalizacja na żądanie
  • 10.5.13. Bezpieczna publikacja
  • 10.5.14. Współdzielenie zmiennych lokalnych wątków
• 10.6. Kolekcje bezpieczne wątkowo
  • 10.6.1. Kolejki blokujące
  • 10.6.2. Szybkie słowniki, zbiory i kolejki
  • 10.6.3. Atomowe modyfikowanie elementów słowników
  • 10.6.4. Operacje masowe na współbieżnych słownikach skrótów
  • 10.6.5. Współbieżne widoki zbiorów
  • 10.6.6. Tablice kopiowane przy zapisie
  • 10.6.7. Równoległe algorytmy tablicowe
  • 10.6.8. Starsze kolekcje bezpieczne wątkowo
• 10.7. Obliczenia asynchroniczne
  • 10.7.1. Klasa CompletableFuture
  • 10.7.2. Tworzenie obiektów CompletableFuture
  • 10.7.3. Czasochłonne zadania w wywołaniach zwrotnych interfejsu użytkownika
• 10.8. Procesy
  • 10.8.1. Budowanie procesu
  • 10.8.2. Uruchamianie procesu
  • 10.8.3. Uchwyty procesów

Rozdział 11. Adnotacje

• 11.1. Stosowanie adnotacji
  • 11.1.1. Elementy adnotacji
  • 11.1.2. Powielanie i mnożenie adnotacji
  • 11.1.3. Adnotacje deklaracji
  • 11.1.4. Adnotacje zastosowań typów
  • 11.1.5. Określanie adresatów wprost
• 11.2. Definiowanie adnotacji
• 11.3. Adnotacje w API Javy
  • 11.3.1. Adnotacje kompilacji
  • 11.3.2. Metaadnotacje
• 11.4. Przetwarzanie adnotacji podczas działania programu
• 11.5. Przetwarzanie adnotacji w kodzie źródłowym
  • 11.5.1. Procesory adnotacji
  • 11.5.2. Interfejs programowy modelu języka
  • 11.5.3. Stosowanie adnotacji do generacji kodu źródłowego
• 11.6. Inżynieria kodu bajtowego
  • 11.6.1. Modyfikowanie plików klasowych
  • 11.6.2. Modyfikacja kodu bajtowego podczas ładowania

Rozdział 12. System modułów platformy Javy

• 12.1. Pojęcie modułu
• 12.2. Nadawanie nazw modułom
• 12.3. Modularny program "Witaj, świecie!"
• 12.4. Żądanie użycia modułów
• 12.5. Eksportowanie pakietów
• 12.6. Modularne pliki JAR
• 12.7. Moduły a technika refleksji
• 12.8. Moduły automatyczne
• 12.9. Moduł nienazwany
• 12.10. Flagi wiersza poleceń stosowane podczas migracji
• 12.11. Wymagania przechodnie i statyczne
• 12.12. Eksport kwalifikowany i otwieranie
• 12.13. Wczytywanie usług
• 12.14. Narzędzia do pracy z modułami

Dodatek A

Skorowidz

pokaż cały spis treści

ukryj recenzje