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 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.
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.
Darmowy fragment publikacji:
Tytuł oryginału: Core Java® for the Impatient
Tłumaczenie: Andrzej Stefański
Projekt okładki: Studio Gravite / Olsztyn
Obarek, Pokoński, Pazdrijowski, Zaprucki
ISBN: 978-83-283-1333-0
Authorized translation from the English language edition, entitled: CORE JAVA FOR THE IMPATIENT;
ISBN 0321996321; by Cay S. Horstmann; published by Pearson Education, Inc, publishing as Addison
Wesley.
Copyright © 2015 Pearson Education, Inc.
All rights reserved. No part of this book may by reproduced or transmitted in any form or by any means,
electronic or mechanical, including photocopying, recording or by any information storage retrieval system,
without permission from Pearson Education, Inc.
Polish language edition published by HELION S.A. Copyright © 2015.
Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej
publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną,
fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje
naruszenie praw autorskich niniejszej publikacji.
Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich
właścicieli.
Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock Images LLC.
Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były
kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane
z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie
ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji
zawartych w książce.
Wydawnictwo HELION
ul. Kościuszki 1c, 44-100 GLIWICE
tel. 32 231 22 19, 32 230 98 63
e-mail: helion@helion.pl
WWW: http://helion.pl (księgarnia internetowa, katalog książek)
Pliki z przykładami omawianymi w książce można znaleźć pod adresem:
ftp://ftp.helion.pl/przyklady/jav8pd.zip
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/jav8pd
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Printed in Poland.
• Kup książkę
• Poleć książkę
• Oceń książkę
• Księgarnia internetowa
• Lubię to! » Nasza społeczność
Spis tre(cid:202)ci
Wst(cid:194)p ........................................................................................................................................................15
Podzi(cid:194)kowania .........................................................................................................................................17
O autorze ..................................................................................................................................................19
1.1.
1.2.
1.3.
Rozdzia(cid:196) 1. Podstawowe struktury programistyczne ...........................................................................21
Nasz pierwszy program ................................................................................... 22
1.1.1. Analiza programu „Witaj, (cid:264)wiecie!” ...................................................... 22
1.1.2. Kompilacja i uruchamianie programu w j(cid:246)zyku Java ............................... 24
1.1.3. Wywo(cid:228)ania metod ............................................................................... 25
Typy proste .................................................................................................... 27
Typy ca(cid:228)kowite ................................................................................... 27
1.2.1.
Typy zmiennoprzecinkowe ................................................................... 28
1.2.2.
Typ char ............................................................................................ 29
1.2.3.
1.2.4.
Typ boolean ....................................................................................... 30
Zmienne ........................................................................................................ 30
1.3.1. Deklaracje zmiennych ......................................................................... 30
1.3.2. Nazwy ............................................................................................... 31
1.3.3.
Inicjalizacja ........................................................................................ 31
1.3.4. Sta(cid:228)e ................................................................................................. 31
Dzia(cid:228)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(cid:276)e liczby ........................................................................................ 39
Ci(cid:241)gi znaków .................................................................................................. 39
1.5.1.
(cid:227)(cid:241)czenie ci(cid:241)gów znaków ..................................................................... 40
1.5.2. Wycinanie ci(cid:241)gów znaków ................................................................... 40
1.5.3. Porównywanie ci(cid:241)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(cid:246)zyku Java ........................................................ 44
1.5.
1.4.
Poleć książkęKup książkę 6
Java 8. Przewodnik do(cid:202)wiadczonego programisty
1.8.
1.6.
1.7.
Wej(cid:264)cie i wyj(cid:264)cie ............................................................................................ 46
1.6.1. Wczytywanie danych wej(cid:264)ciowych ........................................................ 46
1.6.2.
Formatowanie generowanych danych ................................................... 47
Kontrola przep(cid:228)ywu ......................................................................................... 49
1.7.1.
Instrukcje warunkowe ......................................................................... 49
1.7.2. P(cid:246)tle ................................................................................................. 51
1.7.3. Przerywanie i kontynuacja ................................................................... 52
1.7.4.
Zasi(cid:246)g zmiennych lokalnych ................................................................ 54
Tablice i listy tablic ......................................................................................... 55
1.8.1. Obs(cid:228)uga tablic ................................................................................... 55
1.8.2.
Tworzenie tablicy ................................................................................ 56
1.8.3. Klasa ArrayList .................................................................................. 57
1.8.4. Klasy opakowuj(cid:241)ce typy proste ............................................................ 58
1.8.5. Rozszerzona p(cid:246)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(cid:254) ................................................................. 61
1.8.9.
Tablice wielowymiarowe ...................................................................... 62
Dekompozycja funkcjonalna ............................................................................. 64
1.9.1. Deklarowanie i wywo(cid:228)ywanie metod statycznych .................................... 64
1.9.2. Parametry tablicowe i zwracane warto(cid:264)ci .............................................. 65
1.9.3.
Zmienna liczba parametrów ................................................................ 65
(cid:231)wiczenia .................................................................................................................... 66
Rozdzia(cid:196) 2. Programowanie obiektowe .................................................................................................69
Praca z obiektami ........................................................................................... 70
2.1.1. Metody dost(cid:246)powe i modyfikuj(cid:241)ce ....................................................... 72
2.1.2. Referencje do obiektu ........................................................................ 72
Implementowanie klas .................................................................................... 74
2.2.1.
Zmienne instancji .............................................................................. 74
2.2.2. Nag(cid:228)ówki metod ................................................................................. 75
2.2.3.
Tre(cid:264)ci metod ..................................................................................... 75
2.2.4. Wywo(cid:228)ania metod instancji .................................................................. 76
2.2.5. Referencja this .................................................................................. 76
2.2.6. Wywo(cid:228)anie przez warto(cid:264)(cid:232) .................................................................... 77
Tworzenie obiektów ........................................................................................ 78
2.3.1.
Implementacja konstruktorów ............................................................. 78
2.3.2. Przeci(cid:241)(cid:276)anie ...................................................................................... 79
2.3.3. Wywo(cid:228)ywanie jednego konstruktora z innego ......................................... 80
2.3.4. Domy(cid:264)lna inicjalizacja ........................................................................ 80
Inicjalizacja zmiennych instancji .......................................................... 81
2.3.5.
2.3.6.
Zmienne instancji z modyfikatorem final .............................................. 81
2.3.7. Konstruktor bez parametrów ............................................................... 82
Statyczne zmienne i metody ............................................................................ 83
2.4.1.
Zmienne statyczne ............................................................................. 83
2.4.2. Sta(cid:228)e statyczne .................................................................................. 83
2.4.3. Statyczne bloki inicjalizacyjne .............................................................. 84
2.4.4. Metody statyczne ............................................................................... 85
2.4.5. Metody wytwórcze .............................................................................. 86
2.4.
1.9.
2.1.
2.2.
2.3.
Poleć książkęKup książkę Spis tre(cid:202)ci
7
2.5.
2.6.
2.7.
Pakiety .......................................................................................................... 86
2.5.1. Deklarowanie pakietów ....................................................................... 87
2.5.2. (cid:263)cie(cid:276)ka klas ...................................................................................... 88
Zasi(cid:246)g pakietu ................................................................................... 90
2.5.3.
2.5.4.
Importowanie klas .............................................................................. 91
2.5.5.
Import metod statycznych ................................................................... 92
Klasy zagnie(cid:276)d(cid:276)one ......................................................................................... 92
2.6.1. Statyczne klasy zagnie(cid:276)d(cid:276)one .............................................................. 92
2.6.2. Klasy wewn(cid:246)trzne .............................................................................. 94
2.6.3. Specjalne regu(cid:228)y sk(cid:228)adni dla klas wewn(cid:246)trznych .................................... 96
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(cid:264)niki .......................................................................................... 99
2.7.7. Opisy pakietów i ogólne .................................................................... 100
2.7.8. Wycinanie komentarzy ...................................................................... 101
(cid:231)wiczenia .................................................................................................................. 101
Rozdzia(cid:196) 3. Interfejsy i wyra(cid:209)enia lambda ...........................................................................................105
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(cid:228)e ............................................................................................... 110
Metody statyczne i domy(cid:264)lne ......................................................................... 111
3.2.1. Metody statyczne ............................................................................. 111
3.2.2. Metody domy(cid:264)lne ............................................................................. 111
3.2.3. Rozstrzyganie konfliktów metod domy(cid:264)lnych ....................................... 112
Przyk(cid:228)ady interfejsów ..................................................................................... 114
Interfejs Comparable ........................................................................ 114
3.3.1.
3.3.2.
Interfejs Comparator ........................................................................ 115
3.3.3.
Interfejs Runnable ............................................................................ 116
3.3.4. Wywo(cid:228)ania zwrotne interfejsu u(cid:276)ytkownika .......................................... 117
Wyra(cid:276)enia lambda ........................................................................................ 118
3.4.1. Sk(cid:228)adnia wyra(cid:276)e(cid:254) lambda ................................................................. 118
3.4.2.
Interfejsy funkcyjne .......................................................................... 119
Referencje do metod i konstruktora ............................................................... 120
3.5.1. Referencje do metod ........................................................................ 121
3.5.2. Referencje konstruktora ................................................................... 122
Przetwarzanie wyra(cid:276)e(cid:254) lambda ....................................................................... 123
3.6.1.
Implementacja odroczonego wykonania ............................................. 123
3.6.2. Wybór interfejsu funkcjonalnego ........................................................ 124
3.6.3.
Implementowanie w(cid:228)asnych interfejsów funkcjonalnych ....................... 125
Wyra(cid:276)enia lambda i zasi(cid:246)g zmiennych ............................................................ 126
3.7.1.
Zasi(cid:246)g zmiennej lambda ................................................................... 126
3.7.2. Dost(cid:246)p do zmiennych zewn(cid:246)trznych ................................................... 127
3.5.
3.2.
3.6.
3.7.
3.1.
3.3.
3.4.
Poleć książkęKup książkę 8
Java 8. Przewodnik do(cid:202)wiadczonego programisty
3.8.
3.9.
4.1.
4.3.
4.2.
Funkcje wy(cid:276)szych rz(cid:246)dów ............................................................................... 129
3.8.1. Metody zwracaj(cid:241)ce funkcje ............................................................... 129
3.8.2. Metody modyfikuj(cid:241)ce funkcje ............................................................ 130
3.8.3. Metody interfejsu Comparator ........................................................... 130
Lokalne klasy wewn(cid:246)trzne ............................................................................. 131
3.9.1. Klasy lokalne ................................................................................... 131
3.9.2. Klasy anonimowe ............................................................................. 132
(cid:231)wiczenia .................................................................................................................. 133
Rozdzia(cid:196) 4. Dziedziczenie i mechanizm refleksji ..................................................................................135
Rozszerzanie klas ......................................................................................... 136
4.1.1. Klasy nadrz(cid:246)dne i podrz(cid:246)dne ............................................................ 136
4.1.2. Definiowanie i dziedziczenie metod klas podrz(cid:246)dnych .......................... 137
4.1.3. Przes(cid:228)anianie metod ......................................................................... 137
4.1.4.
Tworzenie klasy podrz(cid:246)dnej ............................................................... 139
4.1.5. Przypisania klas nadrz(cid:246)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(cid:246)p .......................................................................... 142
4.1.10. Anonimowe klasy podrz(cid:246)dne ............................................................. 143
4.1.11. Dziedziczenie i metody domy(cid:264)lne ....................................................... 143
4.1.12. Wywo(cid:228)ania metod z super ................................................................. 144
Object — najwy(cid:276)sza klasa nadrz(cid:246)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
Wyliczenia .................................................................................................... 153
4.3.1. Sposoby wyliczania .......................................................................... 153
4.3.2. Konstruktory, metody i pola .............................................................. 154
4.3.3.
Zawarto(cid:264)(cid:232) elementów ...................................................................... 155
4.3.4. Elementy statyczne .......................................................................... 155
4.3.5. Wyra(cid:276)enia switch ze sta(cid:228)ymi wyliczeniowymi ....................................... 156
Informacje o typie i zasobach w czasie dzia(cid:228)ania programu .............................. 157
4.4.1. Klasa Class ..................................................................................... 157
4.4.2. Wczytywanie zasobów ....................................................................... 158
4.4.3. Programy wczytuj(cid:241)ce klasy ................................................................ 160
4.4.4. Kontekstowy program wczytuj(cid:241)cy klasy .............................................. 162
4.4.5. Programy do (cid:228)adowania us(cid:228)ug ............................................................ 163
Refleksje ..................................................................................................... 165
4.5.1. Wyliczanie elementów klasy .............................................................. 165
4.5.2. Kontrolowanie obiektów .................................................................... 166
4.5.3. Wywo(cid:228)ywanie metod ......................................................................... 166
Tworzenie obiektów .......................................................................... 167
4.5.4.
4.5.5.
JavaBeans ....................................................................................... 167
4.5.6. Praca z tablicami ............................................................................. 169
4.5.7. Klasa Proxy ..................................................................................... 170
(cid:231)wiczenia .................................................................................................................. 172
4.4.
4.5.
Poleć książkęKup książkę Spis tre(cid:202)ci
9
5.1.
5.2.
5.3.
Rozdzia(cid:196) 5. Wyj(cid:190)tki, asercje i logi .........................................................................................................175
Obs(cid:228)uga wyj(cid:241)tków ......................................................................................... 176
5.1.1. Wyrzucanie wyj(cid:241)tków ........................................................................ 176
5.1.2. Hierarchia wyj(cid:241)tków .......................................................................... 177
5.1.3. Deklarowanie wyj(cid:241)tków kontrolowanych ............................................. 179
5.1.4. Przechwytywanie wyj(cid:241)tków ................................................................ 180
5.1.5. Wyra(cid:276)enie try z okre(cid:264)leniem zasobów ................................................ 181
5.1.6. Klauzula finally ................................................................................ 182
5.1.7. Ponowne wyrzucanie wyj(cid:241)tków i (cid:228)(cid:241)czenie ich w (cid:228)a(cid:254)cuchy ...................... 183
5.1.8. (cid:263)ledzenie stosu ............................................................................... 185
5.1.9. Metoda Objects.requireNonNull ......................................................... 185
Asercje ........................................................................................................ 186
5.2.1. U(cid:276)ycie asercji .................................................................................. 186
5.2.2. W(cid:228)(cid:241)czanie i wy(cid:228)(cid:241)czanie asercji ........................................................... 187
Rejestrowanie danych ................................................................................... 188
5.3.1. Klasa Logger ................................................................................... 188
5.3.2. Mechanizmy rejestruj(cid:241)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(cid:228)uguj(cid:241)ce rejestrowanie danych ....................................... 192
5.3.7.
Filtry i formaty .................................................................................. 194
(cid:231)wiczenia .................................................................................................................. 195
Rozdzia(cid:196) 6. Programowanie uogólnione ...............................................................................................197
Klasy uogólnione .......................................................................................... 198
Metody uogólnione ....................................................................................... 199
Ograniczenia typów ....................................................................................... 200
Zmienno(cid:264)(cid:232) typów i symbole wieloznaczne ....................................................... 201
6.4.1. Symbole wieloznaczne w typach podrz(cid:246)dnych ..................................... 202
6.4.2. Symbole wieloznaczne typów nadrz(cid:246)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
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
Ograniczenia uogólnie(cid:254) ................................................................................. 209
6.6.1. Brak typów prostych ......................................................................... 209
6.6.2. W czasie dzia(cid:228)ania kodu wszystkie typy s(cid:241) surowe .............................. 209
6.6.3. Nie mo(cid:276)esz tworzy(cid:232) instancji zmiennych opisuj(cid:241)cych typy .................... 210
6.6.4. Nie mo(cid:276)esz tworzy(cid:232) tablic z parametryzowanym typem ........................ 212
6.6.5.
Zmienne opisuj(cid:241)ce typ klasy nie s(cid:241) poprawne
w kontek(cid:264)cie statycznym .................................................................. 213
6.6.6. Metody nie mog(cid:241) wywo(cid:228)ywa(cid:232) konfliktów po wymazywaniu typów ........... 213
6.6.7. Wyj(cid:241)tki i uogólnienia ........................................................................ 214
Refleksje i uogólnienia .................................................................................. 215
6.7.1. Klasa Class T ............................................................................... 215
6.7.2.
Informacje o uogólnionych typach w maszynie wirtualnej ..................... 216
(cid:231)wiczenia .................................................................................................................. 218
6.1.
6.2.
6.3.
6.4.
6.5.
6.6.
6.7.
Poleć książkęKup książkę 10
Java 8. Przewodnik do(cid:202)wiadczonego programisty
7.1.
7.2.
7.3.
7.4.
7.5.
7.6.
8.1.
8.2.
8.3.
8.4.
8.5.
8.6.
8.7.
Rozdzia(cid:196) 7. Kolekcje ...............................................................................................................................221
Mechanizmy do zarz(cid:241)dzania kolekcjami .......................................................... 222
Iteratory ....................................................................................................... 225
Zestawy ....................................................................................................... 226
Mapy ........................................................................................................... 227
Inne kolekcje ................................................................................................ 230
7.5.1. W(cid:228)a(cid:264)ciwo(cid:264)ci ..................................................................................... 231
Zestawy bitów .................................................................................. 231
7.5.2.
7.5.3.
Zestawy wyliczeniowe i mapy ............................................................ 233
7.5.4. Stosy, kolejki zwyk(cid:228)e i dwukierunkowe oraz kolejki z priorytetami .......... 234
7.5.5. Klasa WeakHashMap ....................................................................... 235
Widoki ......................................................................................................... 235
7.6.1.
Zakresy ........................................................................................... 236
7.6.2. Widoki puste i typu singleton ............................................................ 236
7.6.3. Niemodyfikowalne widoki .................................................................. 237
(cid:231)wiczenia .................................................................................................................. 238
Rozdzia(cid:196) 8. Strumienie ...........................................................................................................................241
Od iteratorów do operacji strumieniowych ....................................................... 242
Tworzenie strumienia .................................................................................... 244
Metody filter, map i flatMap .......................................................................... 245
Wycinanie podstrumieni i (cid:228)(cid:241)czenie strumieni ................................................... 246
Inne przekszta(cid:228)cenia strumieni ....................................................................... 247
Proste redukcje ............................................................................................ 247
Typ Optional ................................................................................................. 248
Jak korzysta(cid:232) z warto(cid:264)ci Optional ...................................................... 249
8.7.1.
Jak nie korzysta(cid:232) z warto(cid:264)ci Optional ................................................. 250
8.7.2.
8.7.3.
Tworzenie warto(cid:264)ci Optional .............................................................. 250
8.7.4.
(cid:227)(cid:241)czenie flatMap z funkcjami warto(cid:264)ci Optional .................................. 250
Kolekcje wyników .......................................................................................... 251
8.8.
Tworzenie map ............................................................................................. 252
8.9.
Grupowanie i partycjonowanie ........................................................................ 254
8.10.
Kolektory strumieniowe ................................................................................. 255
8.11.
Operacje redukcji .......................................................................................... 256
8.12.
Strumienie typów prostych ............................................................................ 257
8.13.
8.14.
Strumienie równoleg(cid:228)e .................................................................................. 259
(cid:231)wiczenia .................................................................................................................. 261
Rozdzia(cid:196) 9. Przetwarzanie danych wej(cid:202)ciowych i wyj(cid:202)ciowych ......................................................263
Strumienie wej(cid:264)ciowe i wyj(cid:264)ciowe, mechanizmy wczytuj(cid:241)ce i zapisuj(cid:241)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(cid:246)pie .............................................................. 272
9.1.9. Pliki mapowane w pami(cid:246)ci ................................................................ 272
9.1.10. Blokowanie plików ............................................................................ 273
9.1.
Poleć książkęKup książkę Spis tre(cid:202)ci
11
9.2.
9.5.
10.1.
10.2.
9.3.
9.4.
(cid:263)cie(cid:276)ki, pliki i katalogi ................................................................................... 273
9.2.1. (cid:263)cie(cid:276)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
Po(cid:228)(cid:241)czenia URL ............................................................................................ 280
Wyra(cid:276)enia regularne ...................................................................................... 281
9.4.1. Sk(cid:228)adnia wyra(cid:276)e(cid:254) regularnych ............................................................ 281
9.4.2. Odnajdywanie jednego lub wszystkich dopasowa(cid:254) ............................... 285
9.4.3. Grupy .............................................................................................. 286
9.4.4. Usuwanie lub zast(cid:246)powanie dopasowa(cid:254) ............................................ 287
9.4.5.
Flagi ............................................................................................... 288
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
(cid:231)wiczenia .................................................................................................................. 294
Rozdzia(cid:196) 10. Programowanie wspó(cid:196)bie(cid:209)ne ..........................................................................................297
Zadania wspó(cid:228)bie(cid:276)ne .................................................................................... 298
10.1.1. Uruchamianie zada(cid:254) ......................................................................... 299
10.1.2. Obiekty Future i Executor .................................................................. 300
Bezpiecze(cid:254)stwo w(cid:241)tków ................................................................................ 302
10.2.1. Widoczno(cid:264)(cid:232) ..................................................................................... 302
10.2.2. Wy(cid:264)cigi ........................................................................................... 304
10.2.3. Strategie bezpiecznego korzystania ze wspó(cid:228)bie(cid:276)no(cid:264)ci ........................ 306
10.2.4. Klasy niemodyfikowalne .................................................................... 307
Algorytmy równoleg(cid:228)e .................................................................................... 308
10.3.1. Strumienie równoleg(cid:228)e ...................................................................... 308
10.3.2. Równoleg(cid:228)e operacje na tablicach ...................................................... 309
Struktury danych bezpieczne dla w(cid:241)tków ........................................................ 310
10.4.1. Klasa ConcurrentHashMap ............................................................... 310
10.4.2. Kolejki blokuj(cid:241)ce .............................................................................. 312
10.4.3. Inne struktury danych bezpieczne dla w(cid:241)tków ..................................... 313
Warto(cid:264)ci atomowe ........................................................................................ 314
Blokady ....................................................................................................... 316
10.6.1. Blokady wielowej(cid:264)ciowe .................................................................... 316
10.6.2. S(cid:228)owo kluczowe synchronized ............................................................ 317
10.6.3. Oczekiwanie warunkowe ................................................................... 319
W(cid:241)tki ........................................................................................................... 321
10.7.1. Uruchamianie w(cid:241)tku ......................................................................... 321
10.7.2. Przerywanie w(cid:241)tków ......................................................................... 322
10.7.3. Zmienne lokalne w w(cid:241)tku ................................................................. 323
10.7.4. Dodatkowe w(cid:228)a(cid:264)ciwo(cid:264)ci w(cid:241)tku .......................................................... 324
Obliczenia asynchroniczne ............................................................................. 325
10.8.1. D(cid:228)ugie zadania obs(cid:228)uguj(cid:241)ce interfejs u(cid:276)ytkownika ............................... 325
10.8.2. Klasa CompletableFuture .................................................................. 326
10.5.
10.6.
10.3.
10.4.
10.7.
10.8.
Poleć książkęKup książkę 12
Java 8. Przewodnik do(cid:202)wiadczonego programisty
10.9.
11.2.
11.3.
11.4.
11.5.
11.1.
Procesy ....................................................................................................... 329
10.9.1. Tworzenie procesu ........................................................................... 329
10.9.2. Uruchamianie procesu ...................................................................... 331
(cid:231)wiczenia .................................................................................................................. 331
Rozdzia(cid:196) 11. Adnotacje ...........................................................................................................................337
U(cid:276)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(cid:264)lanie odbiorców .............................................................. 342
Definiowanie adnotacji .................................................................................. 343
Adnotacje standardowe ................................................................................. 345
11.3.1. Adnotacje do kompilacji .................................................................... 345
11.3.2. Adnotacje do zarz(cid:241)dzania zasobami ................................................... 347
11.3.3. Metaadnotacje ................................................................................. 347
Przetwarzanie adnotacji w kodzie ................................................................... 349
Przetwarzanie adnotacji w kodzie (cid:274)ród(cid:228)owym ................................................... 352
11.5.1. Przetwarzanie adnotacji .................................................................... 352
11.5.2. API modelu j(cid:246)zyka ............................................................................ 353
11.5.3. Wykorzystanie adnotacji do generowania kodu (cid:274)ród(cid:228)owego .................. 353
(cid:231)wiczenia .................................................................................................................. 356
Rozdzia(cid:196) 12. API daty i czasu .................................................................................................................357
Linia czasu ................................................................................................... 358
12.1.
Daty lokalne ................................................................................................. 360
12.2.
Modyfikatory daty ......................................................................................... 362
12.3.
Czas lokalny ................................................................................................. 363
12.4.
Czas strefowy ............................................................................................... 364
12.5.
Formatowanie i przetwarzanie ........................................................................ 367
12.6.
12.7.
Wspó(cid:228)praca z przestarza(cid:228)ym kodem ................................................................ 370
(cid:231)wiczenia .................................................................................................................. 371
Rozdzia(cid:196) 13. Internacjonalizacja ...........................................................................................................373
Lokalizacje ................................................................................................... 374
13.1.1. Okre(cid:264)lanie lokalizacji ........................................................................ 375
13.1.2. Domy(cid:264)lna lokalizacja ........................................................................ 377
13.1.3. Nazwy wy(cid:264)wietlane ........................................................................... 378
Formaty liczb ................................................................................................ 378
Waluty ......................................................................................................... 379
Formatowanie czasu i daty ............................................................................ 380
Porównywanie i normalizacja ......................................................................... 382
Formatowanie komunikatów .......................................................................... 383
Pakiety z zasobami ....................................................................................... 385
13.7.1. Organizacja pakietów z zasobami ...................................................... 385
13.7.2. Klasy z pakietami ............................................................................. 387
Kodowanie znaków ....................................................................................... 388
13.8.
13.9.
Preferencje .................................................................................................. 389
(cid:231)wiczenia .................................................................................................................. 391
13.2.
13.3.
13.4.
13.5.
13.6.
13.7.
13.1.
Poleć książkęKup książkę Spis tre(cid:202)ci
13
14.1.
14.2.
Rozdzia(cid:196) 14. Kompilacja i skryptowanie ...............................................................................................393
API kompilatora ............................................................................................ 394
14.1.1. Wywo(cid:228)anie kompilatora ..................................................................... 394
14.1.2. Uruchamianie zadania kompilacji ....................................................... 394
14.1.3. Wczytywanie plików (cid:274)ród(cid:228)owych z pami(cid:246)ci ........................................... 395
14.1.4. Zapisywanie skompilowanego kodu w pami(cid:246)ci .................................... 396
14.1.5. Przechwytywanie komunikatów diagnostycznych .................................. 397
API skryptów ................................................................................................ 397
14.2.1. Tworzenie silnika skryptowego .......................................................... 398
14.2.2. Powi(cid:241)zania ...................................................................................... 399
14.2.3. Przekierowanie wej(cid:264)cia i wyj(cid:264)cia ........................................................ 399
14.2.4. Wywo(cid:228)ywanie funkcji i metod skryptowych .......................................... 400
14.2.5. Kompilowanie skryptu ...................................................................... 401
Silnik skryptowy Nashorn .............................................................................. 401
14.3.1. Uruchamianie Nashorna z wiersza polece(cid:254) ......................................... 402
14.3.2. Wywo(cid:228)ywanie metod pobieraj(cid:241)cych i ustawiaj(cid:241)cych dane
14.3.
oraz metod prze(cid:228)adowanych .............................................................. 403
14.3.3. Tworzenie obiektów j(cid:246)zyka Java ......................................................... 403
14.3.4. Ci(cid:241)gi znaków w j(cid:246)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(cid:276)enia lambda ............................................................................ 407
14.3.9. Rozszerzanie klas Java i implementowanie interfejsów Java ................ 408
14.3.10.Wyj(cid:241)tki ............................................................................................ 409
Skrypty pow(cid:228)oki z silnikiem Nashorn ............................................................... 410
14.4.1. Wykonywanie polece(cid:254) pow(cid:228)oki ........................................................... 410
14.4.2. Uzupe(cid:228)nianie ci(cid:241)gów znaków ............................................................. 411
14.4.3. Wprowadzanie danych do skryptu ...................................................... 412
(cid:231)wiczenia .................................................................................................................. 413
14.4.
Skorowidz ..............................................................................................................................................415
Poleć książkęKup książkę 14
Java 8. Przewodnik do(cid:202)wiadczonego programisty
Poleć książkęKup książkę 3
Interfejsy i wyra(cid:209)enia lambda
W tym rozdziale
(cid:81) 3.1. Interfejsy
(cid:81) 3.2. Metody statyczne i domy(cid:286)lne
(cid:81) 3.3. Przyk(cid:225)ady interfejsów
(cid:81) 3.4. Wyra(cid:298)enia lambda
(cid:81) 3.5. Referencje do metod i konstruktora
(cid:81) 3.6. Przetwarzanie wyra(cid:298)e(cid:276) lambda
(cid:81) 3.7. Wyra(cid:298)enia lambda i zasi(cid:266)g zmiennych
(cid:81) 3.8. Funkcje wy(cid:298)szych rz(cid:266)dów
(cid:81) 3.9. Lokalne klasy wewn(cid:266)trzne
(cid:81) (cid:251)wiczenia
Java zosta(cid:225)a zaprojektowana jako obiektowy j(cid:266)zyk programowania w latach 90. ubieg(cid:225)ego
wieku, w czasie gdy programowanie obiektowe by(cid:225)o najwa(cid:298)niejszym paradygmatem w two-
rzeniu oprogramowania. Interfejsy s(cid:261) kluczow(cid:261) funkcjonalno(cid:286)ci(cid:261) w programowaniu obiekto-
wym. Pozwalaj(cid:261) na okre(cid:286)lenie, co ma zosta(cid:252) wykonane bez konieczno(cid:286)ci tworzenia imple-
mentacji.
D(cid:225)ugo przed pojawieniem si(cid:266) programowania obiektowego istnia(cid:225)y funkcjonalne j(cid:266)zyki
programowania (takie jak Lisp), w których to funkcje, a nie obiekty, by(cid:225)y najwa(cid:298)niejszym
mechanizmem tworz(cid:261)cym struktur(cid:266) programu. Ostatnio programowanie funkcjonalne jest
coraz wa(cid:298)niejsze, poniewa(cid:298) dobrze sprawdza si(cid:266) w przypadku programowania równoleg(cid:225)ego
i zdarzeniowego („reaktywnego”). Java wspiera wyra(cid:298)enia funkcyjne, które stanowi(cid:261) wygodne
po(cid:225)(cid:261)czenie pomi(cid:266)dzy programowaniem obiektowym a funkcjonalnym. W tym rozdziale
opowiemy o interfejsach i wyra(cid:298)eniach lambda.
Poleć książkęKup książkę 106
Java 8. Przewodnik do(cid:202)wiadczonego programisty
Najwa(cid:298)niejsze punkty tego rozdzia(cid:225)u:
(cid:81) Interfejs okre(cid:286)la zestaw metod, które klasa implementuj(cid:261)ca musi dostarczy(cid:252).
(cid:81) Interfejs stanowi typ nadrz(cid:266)dny (ang. supertype) dla ka(cid:298)dej klasy, która go
implementuje. Dlatego mo(cid:298)na przypisa(cid:252) instancje klasy do zmiennych, których
typ jest okre(cid:286)lony interfejsem.
(cid:81) Interfejs mo(cid:298)e zawiera(cid:252) metody statyczne. Wszystkie zmienne interfejsu
s(cid:261) automatycznie uznawane za statyczne i ostateczne (ang. final).
(cid:81) Interfejs mo(cid:298)e zawiera(cid:252) domy(cid:286)lne metody, które implementuj(cid:261)ca klasa mo(cid:298)e
odziedziczy(cid:252) lub przes(cid:225)oni(cid:252).
(cid:81) Interfejsy Comparable i Comparator s(cid:261) u(cid:298)ywane do porównywania obiektów.
(cid:81) Wyra(cid:298)enie lambda opisuje blok kodu, który mo(cid:298)e by(cid:252) wykonany pó(cid:296)niej.
(cid:81) Wyra(cid:298)enia lambda s(cid:261) konwertowane na interfejsy funkcjonalne.
(cid:81) Referencje metod i konstruktorów odwo(cid:225)uj(cid:261) si(cid:266) do metod lub konstruktorów
bez ich wykonywania.
(cid:81) Wyra(cid:298)enia lambda i lokalne klasy wewn(cid:266)trzne mog(cid:261) uzyskiwa(cid:252) dost(cid:266)p do zmiennych
typu final znajduj(cid:261)cych si(cid:266) w zasi(cid:266)gu klasy zewn(cid:266)trznej.
3.1. Interfejsy
Interfejs to mechanizm pozwalaj(cid:261)cy na zapisanie kontraktu pomi(cid:266)dzy dwoma stronami:
dostawc(cid:261) us(cid:225)ug i klasami, które chc(cid:261), by ich obiekty mog(cid:225)y by(cid:252) wykorzystywane z us(cid:225)ug(cid:261).
W kolejnych podrozdzia(cid:225)ach zobaczysz, jak definiowa(cid:252) i wykorzystywa(cid:252) interfejsy w j(cid:266)zyku
Java.
3.1.1. Deklarowanie interfejsu
Popatrzmy na us(cid:225)ug(cid:266), która operuje na ci(cid:261)gu liczb ca(cid:225)kowitych, daj(cid:261)c informacj(cid:266) o (cid:286)redniej
z pierwszych n warto(cid:286)ci:
public static double average(IntSequence seq, int n)
Takie sekwencje mog(cid:261) przyjmowa(cid:252) wiele form. Oto przyk(cid:225)ady:
(cid:81) ci(cid:261)g liczb ca(cid:225)kowitych wpisany przez u(cid:298)ytkownika,
(cid:81) ci(cid:261)g wylosowanych liczb ca(cid:225)kowitych,
(cid:81) ci(cid:261)g liczb pierwszych,
(cid:81) ci(cid:261)g elementów w tablicy zmiennych typu ca(cid:225)kowitego,
(cid:81) ci(cid:261)g kodów znaków w postaci ci(cid:261)gu znaków (ang. string),
(cid:81) ci(cid:261)g cyfr w liczbie.
Poleć książkęKup książkę Rozdzia(cid:196) 3. (cid:81) Interfejsy i wyra(cid:209)enia lambda
107
Chcemy zaimplementowa(cid:252) jeden mechanizm obs(cid:225)uguj(cid:261)cy wszystkie powy(cid:298)sze rodzaje danych.
Najpierw zobaczmy, jakie wspólne cechy maj(cid:261) ci(cid:261)gi liczb ca(cid:225)kowitych. Aby móc obs(cid:225)u(cid:298)y(cid:252) taki
ci(cid:261)g, potrzebne s(cid:261) co najmniej dwie metody:
(cid:81) sprawdzaj(cid:261)ca, czy istnieje kolejny element,
(cid:81) pobieraj(cid:261)ca kolejny element.
Aby zadeklarowa(cid:252) interfejs, dostarczasz nag(cid:225)ówki metod w taki sposób:
public interface IntSequence {
boolean hasNext();
int next();
}
Nie musisz implementowa(cid:252) tych metod, ale je(cid:286)li chcesz, mo(cid:298)esz dopisa(cid:252) domy(cid:286)ln(cid:261) imple-
mentacj(cid:266) — patrz podrozdzia(cid:225) 3.2.2, „Metody domy(cid:286)lne”. Je(cid:286)li nie ma domy(cid:286)lnej implemen-
tacji, mówimy, (cid:298)e metoda jest abstrakcyjna.
Wszystkie metody interfejsu automatycznie staj(cid:241) si(cid:246) publiczne. Dzi(cid:246)ki temu nie trzeba
dopisywa(cid:232) przy metodach hasNext i next modyfikatora public. Niektórzy programi(cid:264)ci
dopisuj(cid:241) to dla zwi(cid:246)kszenia przejrzysto(cid:264)ci kodu.
Metody w interfejsie wystarcz(cid:261) do zaimplementowania metody wyliczaj(cid:261)cej (cid:286)redni(cid:261) average:
public static double average(IntSequence seq, int n) {
int count = 0;
double sum = 0;
while (seq.hasNext() count n) {
count++;
sum += seq.next();
}
return count == 0 ? 0 : sum / count;
}
3.1.2. Implementowanie interfejsu
Popatrzmy teraz na drug(cid:261) stron(cid:266) medalu: klasy, które maj(cid:261) by(cid:252) wykorzystywane przez metod(cid:266)
average. Musz(cid:261) one implementowa(cid:252) interfejs IntSequence. Oto przyk(cid:225)ad takiej klasy:
public class SquareSequence implements IntSequence {
private int i;
public boolean hasNext() {
return true;
}
public int next() {
i++;
return i * i;
}
}
Poleć książkęKup książkę 108
Java 8. Przewodnik do(cid:202)wiadczonego programisty
Istnieje niesko(cid:276)czenie wiele liczb, które s(cid:261) kwadratem innej liczby ca(cid:225)kowitej, a obiekt tej
klasy mo(cid:298)e zwraca(cid:252) kolejne takie liczby.
S(cid:225)owo kluczowe implements mówi o tym, (cid:298)e klasa SquareSequence b(cid:266)dzie obs(cid:225)ugiwa(cid:225)a interfejs
IntSequence.
Klasa implementuj(cid:241)ca musi deklarowa(cid:232) metody interfejsu jako publiczne. W przeciw-
nym wypadku b(cid:246)d(cid:241) one mia(cid:228)y zasi(cid:246)g pakietu. Poniewa(cid:276) interfejs wymaga, by metoda
by(cid:228)a publiczna, kompilator zg(cid:228)osi b(cid:228)(cid:241)d.
Poni(cid:298)szy kod oblicza (cid:286)redni(cid:261) ze 100 pierwszych kwadratów:
SquareSequence squares = new SquareSequence();
double avg = average(squares, 100);
Wiele klas implementuje interfejs IntSequence. Na przyk(cid:225)ad poni(cid:298)sza klasa zwraca sko(cid:276)czony
ci(cid:261)g, a dok(cid:225)adniej: cyfry dodatniej liczby ca(cid:225)kowitej, pocz(cid:261)wszy od najmniej znacz(cid:261)cej:
public class DigitSequence implements IntSequence {
private int number;
public DigitSequence(int n) {
number = n;
}
public boolean hasNext() {
return number != 0;
}
public int next() {
int result = number 10;
number /= 10;
return result;
}
public int rest() {
return number;
}
}
Obiekt new DigitSequence(1729) zwraca cyfry: 9, 2, 7, 1, zanim funkcja hasNext zwróci false.
Klasy SquareSequence i DigitSequence implementuj(cid:241) wszystkie metody interfejsu
IntSequence. Je(cid:264)li klasa implementuje tylko niektóre z metod, musi by(cid:232) zadeklaro-
wana z modyfikatorem abstract. W rozdziale 4. znajdziesz wi(cid:246)cej informacji na temat
klas abstrakcyjnych.
3.1.3. Konwersja do typu interfejsu
Poni(cid:298)szy fragment kodu oblicza (cid:286)redni(cid:261) z warto(cid:286)ci ci(cid:261)gu cyfr:
Poleć książkęKup książkę Rozdzia(cid:196) 3. (cid:81) Interfejsy i wyra(cid:209)enia lambda
109
IntSequence digits = new DigitSequence(1729);
double avg = average(digits, 100);
// Przejrzy tylko cztery pierwsze warto(cid:286)ci z ci(cid:261)gu
Popatrz na zmienn(cid:261) digits. Jej typ to IntSequence, nie DigitSequence. Zmienna typu Int
(cid:180)Sequence odwo(cid:225)uje si(cid:266) do obiektu dowolnej klasy implementuj(cid:261)cej interfejs IntSequence.
Mo(cid:298)esz zawsze przypisa(cid:252) do zmiennej obiekt, którego typ jest okre(cid:286)lony implementowanym
interfejsem, lub przekaza(cid:252) go do metody oczekuj(cid:261)cej zmiennej z takim interfejsem.
A oto odrobina przydatnej terminologii. Typ S to typ nadrz(cid:266)dny typu T (podtypu), je(cid:286)li dowolna
warto(cid:286)(cid:252) podtypu mo(cid:298)e by(cid:252) przypisana do zmiennej typu nadrz(cid:266)dnego bez konwersji. Na
przyk(cid:225)ad interfejs IntSequence jest typem nadrz(cid:266)dnym klasy DigitSequence.
Cho(cid:232) mo(cid:276)na deklarowa(cid:232) zmienne, u(cid:276)ywaj(cid:241)c interfejsu jako ich typu, nie jest mo(cid:276)liwe
utworzenie instancji obiektu, którego typem b(cid:246)dzie interfejs. Wszystkie obiekty musz(cid:241)
by(cid:232) instancjami klas.
3.1.4. Rzutowanie i operator instanceof
Czasem b(cid:266)dziesz potrzebowa(cid:225) odwrotnej konwersji — z typu nadrz(cid:266)dnego do podtypu. Wtedy
zastosuj rzutowanie. Na przyk(cid:225)ad je(cid:286)li zdarzy si(cid:266), (cid:298)e obiekt wskazywany przez zmienn(cid:261)
typu IntSequence jest w rzeczywisto(cid:286)ci typu DigitSequence, mo(cid:298)esz wykona(cid:252) konwersj(cid:266) typu
w taki sposób:
IntSequence sequence = ...;
DigitSequence digits = (DigitSequence) sequence;
System.out.println(digits.rest());
W tej sytuacji rzutowanie by(cid:225)o potrzebne, poniewa(cid:298) rest to metoda klasy DigitSequence, ale
nie ma jej w IntSequence.
W (cid:252)wiczeniu 2. znajduje si(cid:266) lepszy przyk(cid:225)ad.
Mo(cid:298)esz wykona(cid:252) rzutowanie obiektu jedynie do typu jego rzeczywistej klasy lub jednego
z jego typów nadrz(cid:266)dnych. Je(cid:286)li wykonasz nieprawid(cid:225)owe rzutowanie, zostanie zg(cid:225)oszony b(cid:225)(cid:261)d
kompilacji lub wyj(cid:261)tek rzutowania klasy:
String digitString = (String) sequence;
// Nie mo(cid:298)e zadzia(cid:225)a(cid:252) — IntSequence nie jest typem nadrz(cid:266)dnym dla String
RandomSequence randoms = (RandomSequence) sequence;
// Mo(cid:298)e zadzia(cid:225)a(cid:252), zwróci wyj(cid:261)tek class cast exception, je(cid:286)li si(cid:266) nie powiedzie
Aby unikn(cid:261)(cid:252) zg(cid:225)oszenia wyj(cid:261)tku, mo(cid:298)esz przed wykonaniem rzutowania sprawdzi(cid:252), czy jest
to mo(cid:298)liwe za pomoc(cid:261) operatora instanceof. Wyra(cid:298)enie
obiekt instanceof Typ
zwraca true, je(cid:286)li obiekt jest instancj(cid:261) klasy, dla której Typ jest typem nadrz(cid:266)dnym. Warto to
sprawdza(cid:252) przed wykonaniem rzutowania.
Poleć książkęKup książkę 110
Java 8. Przewodnik do(cid:202)wiadczonego programisty
if (sequence instanceof DigitSequence) {
DigitSequence digits = (DigitSequence) sequence;
...
}
3.1.5. Rozszerzanie interfejsów
Interfejs mo(cid:298)e rozszerza(cid:252) inny interfejs, dok(cid:225)adaj(cid:261)c dodatkowe metody do oryginalnych. Na
przyk(cid:225)ad Closeable to interfejs z jedn(cid:261) metod(cid:261):
public interface Closeable {
void close();
}
Jak zobaczysz w rozdziale 5., jest to wa(cid:298)ny interfejs wykorzystywany do zwalniania zasobów
w sytuacji, gdy wyst(cid:261)pi wyj(cid:261)tek.
Interfejs Channel rozszerza ten interfejs:
public interface Channel extends Closeable {
boolean isOpen();
}
Klasa, która implementuje interfejs Channel, musi obs(cid:225)ugiwa(cid:252) obie metody, a jej obiekty
mog(cid:261) by(cid:252) konwertowane do obu typów interfejsów.
3.1.6. Implementacja wielu interfejsów
Klasa mo(cid:298)e implementowa(cid:252) dowoln(cid:261) liczb(cid:266) interfejsów. Na przyk(cid:225)ad klasa FileSequence, która
wczytuje liczby ca(cid:225)kowite z pliku, mo(cid:298)e implementowa(cid:252) interfejs Closeable i IntSequence:
public class FileSequence implements IntSequence, Closeable {
...
}
W takiej sytuacji klasa FileSequence ma dwa typy nadrz(cid:266)dne: IntSequence i Closeable.
3.1.7. Sta(cid:196)e
Ka(cid:298)da zmienna zdefiniowana w interfejsie automatycznie otrzymuje atrybuty public static
final.
Na przyk(cid:225)ad interfejs SwingConstants definiuje sta(cid:225)e opisuj(cid:261)ce kierunki na kompasie:
public interface SwingConstants {
int NORTH = 1;
int NORTH_EAST = 2;
int EAST = 3;
...
}
Poleć książkęKup książkę Rozdzia(cid:196) 3. (cid:81) Interfejsy i wyra(cid:209)enia lambda
111
Mo(cid:298)esz odwo(cid:225)ywa(cid:252) si(cid:266) do nich za pomoc(cid:261) pe(cid:225)nej nazwy SwingConstants.NORTH. Je(cid:286)li Twoja
klasa zechce implementowa(cid:252) interfejs SwingConstants, mo(cid:298)esz opu(cid:286)ci(cid:252) przedrostek Swing
(cid:180)Constants i napisa(cid:252) jedynie NORTH. Nie jest to jednak cz(cid:266)sto wykorzystywane. Du(cid:298)o lepiej
w przypadku zestawu sta(cid:225)ych wykorzysta(cid:252) typ wyliczeniowy — patrz rozdzia(cid:225) 4.
Nie mo(cid:276)esz umie(cid:264)ci(cid:232) w interfejsie zmiennych instancji. Interfejs okre(cid:264)la zachowanie,
a nie stan obiektu.
3.2. Metody statyczne i domy(cid:202)lne
W starszych wersjach j(cid:266)zyka Java wszystkie metody interfejsu musia(cid:225)y by(cid:252) abstrakcyjne —
to znaczy bez implementacji. Obecnie mo(cid:298)esz doda(cid:252) metody z implementacj(cid:261) na dwa spo-
soby: jako metody statyczne i metody domy(cid:286)lne. Poni(cid:298)sze podrozdzia(cid:225)y opisuj(cid:261) tego typu
metody.
3.2.1. Metody statyczne
Nigdy nie by(cid:225)o technicznych przeszkód, aby interfejs móg(cid:225) posiada(cid:252) metody statyczne, ale nie
pasowa(cid:225)y one do roli interfejsów jako abstrakcyjnej specyfikacji. To podej(cid:286)cie si(cid:266) zmieni(cid:225)o.
Szczególnie metody wytwórcze pasuj(cid:261) do interfejsów. Na przyk(cid:225)ad interfejs IntSequence
mo(cid:298)e mie(cid:252) statyczn(cid:261) metod(cid:266) digitsOf generuj(cid:261)c(cid:261) ci(cid:261)g cyfr z przekazanej liczby ca(cid:225)kowitej:
IntSequence digits = IntSequence.digitsOf(1729);
Metoda zwraca instancj(cid:266) klasy implementuj(cid:261)cej interfejs IntSequence, ale przy wywo(cid:225)ywaniu
nie ma znaczenia, która to b(cid:266)dzie klasa.
public interface IntSequence {
...
public static IntSequence digitsOf(int n) {
return new DigitSequence(n);
}
}
W przesz(cid:228)o(cid:264)ci cz(cid:246)sto umieszczano metody statyczne w dodatkowej klasie. W biblio-
tece standardowej mo(cid:276)na znale(cid:274)(cid:232) pary zawieraj(cid:241)ce interfejs i dodatkow(cid:241) klas(cid:246),
takie jak Collection/Collections lub Path/Paths. Taki podzia(cid:228) nie jest ju(cid:276) konieczny.
3.2.2. Metody domy(cid:202)lne
Mo(cid:298)esz dostarczy(cid:252) domy(cid:286)ln(cid:261) implementacj(cid:266) dowolnej metody interfejsu. Musisz oznaczy(cid:252)
tak(cid:261) metod(cid:266) modyfikatorem default.
public interface IntSequence {
default boolean hasNext() { return true; }
Poleć książkęKup książkę 112
Java 8. Przewodnik do(cid:202)wiadczonego programisty
// Domy(cid:286)lnie sekwencje s(cid:261) niesko(cid:276)czone
int next();
}
Klasa implementuj(cid:261)ca ten i
Pobierz darmowy fragment (pdf)
