Facebook - konwersja

Java 8. Przewodnik doświadczonego programisty - ebook

Wydawnictwo:
Tłumacz:
Data wydania:
3 listopada 2015
Format ebooka:
EPUB
Format EPUB
czytaj
na czytniku
czytaj
na tablecie
czytaj
na smartfonie
Jeden z najpopularniejszych formatów e-booków na świecie. Niezwykle wygodny i przyjazny czytelnikom - w przeciwieństwie do formatu PDF umożliwia skalowanie czcionki, dzięki czemu możliwe jest dopasowanie jej wielkości do kroju i rozmiarów ekranu. Więcej informacji znajdziesz w dziale Pomoc.
Multiformat
E-booki w Virtualo.pl dostępne są w opcji multiformatu. Oznacza to, że po dokonaniu zakupu, e-book pojawi się na Twoim koncie we wszystkich formatach dostępnych aktualnie dla danego tytułu. Informacja o dostępności poszczególnych formatów znajduje się na karcie produktu.
, PDF
Format PDF
czytaj
na laptopie
czytaj
na tablecie
Format e-booków, który możesz odczytywać na tablecie oraz laptopie. Pliki PDF są odczytywane również przez czytniki i smartfony, jednakze względu na komfort czytania i brak możliwości skalowania czcionki, czytanie plików PDF na tych urządzeniach może być męczące dla oczu. Więcej informacji znajdziesz w dziale Pomoc.
Multiformat
E-booki w Virtualo.pl dostępne są w opcji multiformatu. Oznacza to, że po dokonaniu zakupu, e-book pojawi się na Twoim koncie we wszystkich formatach dostępnych aktualnie dla danego tytułu. Informacja o dostępności poszczególnych formatów znajduje się na karcie produktu.
, MOBI
Format MOBI
czytaj
na czytniku
czytaj
na tablecie
czytaj
na smartfonie
Jeden z najczęściej wybieranych formatów wśród czytelników e-booków. Możesz go odczytać na czytniku Kindle oraz na smartfonach i tabletach po zainstalowaniu specjalnej aplikacji. Więcej informacji znajdziesz w dziale Pomoc.
Multiformat
E-booki w Virtualo.pl dostępne są w opcji multiformatu. Oznacza to, że po dokonaniu zakupu, e-book pojawi się na Twoim koncie we wszystkich formatach dostępnych aktualnie dla danego tytułu. Informacja o dostępności poszczególnych formatów znajduje się na karcie produktu.
(3w1)
Multiformat
E-booki sprzedawane w księgarni Virtualo.pl dostępne są w opcji multiformatu - kupujesz treść, nie format. Po dodaniu e-booka do koszyka i dokonaniu płatności, e-book pojawi się na Twoim koncie w Mojej Bibliotece we wszystkich formatach dostępnych aktualnie dla danego tytułu. Informacja o dostępności poszczególnych formatów znajduje się na karcie produktu przy okładce. Uwaga: audiobooki nie są objęte opcją multiformatu.
czytaj
na laptopie
Pliki PDF zabezpieczone watermarkiem możesz odczytać na dowolnym laptopie po zainstalowaniu czytnika dokumentów PDF. Najpowszechniejszym programem, który umożliwi odczytanie pliku PDF na laptopie, jest Adobe Reader. W zależności od potrzeb, możesz zainstalować również inny program - e-booki PDF pod względem sposobu odczytywania nie różnią niczym od powszechnie stosowanych dokumentów PDF, które odczytujemy każdego dnia.
Informacje na temat zabezpieczenia e-booka znajdziesz na karcie produktu w "Szczegółach na temat e-booka". Więcej informacji znajdziesz w dziale Pomoc.
czytaj
na tablecie
Aby odczytywać e-booki na swoim tablecie musisz zainstalować specjalną aplikację. W zależności od formatu e-booka oraz systemu operacyjnego, który jest zainstalowany na Twoim urządzeniu może to być np. Bluefire dla EPUBa lub aplikacja Kindle dla formatu MOBI.
Informacje na temat zabezpieczenia e-booka znajdziesz na karcie produktu w "Szczegółach na temat e-booka". Więcej informacji znajdziesz w dziale Pomoc.
czytaj
na czytniku
Czytanie na e-czytniku z ekranem e-ink jest bardzo wygodne i nie męczy wzroku. Pliki przystosowane do odczytywania na czytnikach to przede wszystkim EPUB (ten format możesz odczytać m.in. na czytnikach PocketBook) i MOBI (ten fromat możesz odczytać m.in. na czytnikach Kindle).
Informacje na temat zabezpieczenia e-booka znajdziesz na karcie produktu w "Szczegółach na temat e-booka". Więcej informacji znajdziesz w dziale Pomoc.
czytaj
na smartfonie
Aby odczytywać e-booki na swoim smartfonie musisz zainstalować specjalną aplikację. W zależności od formatu e-booka oraz systemu operacyjnego, który jest zainstalowany na Twoim urządzeniu może to być np. iBooks dla EPUBa lub aplikacja Kindle dla formatu MOBI.
Informacje na temat zabezpieczenia e-booka znajdziesz na karcie produktu w "Szczegółach na temat e-booka". Więcej informacji znajdziesz w dziale Pomoc.
69,00

Java 8. Przewodnik doświadczonego programisty - ebook

Cay S. Horstmann autor "Java. Podstawy. Wydanie IX" i "Java. Techniki zaawansowane. Wydanie IX" - najpopularniejszych w Polsce podręczników do nauki Javy

Java 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 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.

Niezależnie od tego, czy dopiero zaczynasz poznawanie nowoczesnej Javy, czy jesteś doświadczonym deweloperem, ten przewodnik jest bezcenny dla każdego, kto chce pisać najbardziej niezawodny, wydajny i bezpieczny kod w języku Java.

Spis treści

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)

Kategoria: Programowanie
Zabezpieczenie: Watermark
Watermark
Watermarkowanie polega na znakowaniu plików wewnątrz treści, dzięki czemu możliwe jest rozpoznanie unikatowej licencji transakcyjnej Użytkownika. E-książki zabezpieczone watermarkiem można odczytywać na wszystkich urządzeniach odtwarzających wybrany format (czytniki, tablety, smartfony). Nie ma również ograniczeń liczby licencji oraz istnieje możliwość swobodnego przenoszenia plików między urządzeniami. Pliki z watermarkiem są kompatybilne z popularnymi programami do odczytywania ebooków, jak np. Calibre oraz aplikacjami na urządzenia mobilne na takie platformy jak iOS oraz Android.
ISBN: 978-83-283-1336-1
Rozmiar pliku: 4,0 MB

BESTSELLERY

Kategorie: