Kompletny przewodnik po języku programowania Java
Niniejsza książka, Java. Kompendium programisty. Wydanie IX. została zaktualizowana o nowości wprowadzone w
Java SE 8 i prezentuje sposoby programowania, kompilacji, testowania i uruchamiania programów w języku Java. Herbert Schildt, autor wielu bestsellerowych książek programistycznych, opisuje w niej cały język Java — jego składnię, słowa kluczowe, podstawowe zasady programistyczne, jak również prezentuje znaczącą część biblioteki
Java API . Książka przedstawia także komponenty
JavaBeans ,
serwlety ,
aplety , pakiet
Swing , prezentując przy okazji praktyczne przykłady ilustrujące opisywane zagadnienia w działaniu. Można w niej także znaleźć szczegółowe informacje o nowych możliwościach Javy SE 8, takich jak
wyrażenia lambda ,
biblioteka strumieni , czy też domyślne
metody interfejsów . Znalazło się też w niej wprowadzenie do platformy
JavaFX .
Zagadnienia opisane w książce:
Typy danych, zmienne, tablice i operatory.
Instrukcje sterujące.
Klasy, obiekty i metody.
Przykrywanie i przeciążanie metod.
Dziedziczenie.
Interfejsy i pakiety.
Obsługa wyjątków.
Programowanie wielowątkowe.
Typy wyliczeniowe, automatyczne opakowywanie i adnotacje.
Klasy wejścia-wyjścia.
Typy sparametryzowane.
Wyrażenia lambda.
Obsługa łańcuchów znaków.
Framework Collections.
Programowanie sieciowe.
Obsługa zdarzeń.
Pakiety AWT i Swing.
Interfejs Concurrent API.
Biblioteka strumieni.
Wyrażenia regularne.
Platforma JavaFX.
Komponenty JavaBeans.
Aplety i serwlety.
I znacznie, znacznie więcej.
Herbert Schildt — były członek komitetu ANSI/ISO, który dokonał standaryzacji języka C++. Popularny autor książek poświęconych programowaniu, głównie w językach C, C++, C# i Java. Jego książki, wykorzystywane przez profesjonalistów, szkoleniowców i studentów, rozeszły się w ponad 3 milionach egzemplarzy.
Znajdź podobne książki
Ostatnio czytane w tej kategorii
Darmowy fragment publikacji:
Tytuł oryginału: Java™ The Complete Reference, Ninth Edition
Tłumaczenie: Piotr Rajca
na podstawie „Java. Kompendium programisty. Wydanie VIII”
w tłumaczeniu Mikołaja Szczepaniaka
ISBN: 978-83-283-0812-1
Original edition copyright © 2014 by McGraw-Hill Education (Publisher).
All rights reserved.
Polish edition copyright © 2015 by HELION S.A.
All rights reserved.
All rights reserved. No part of this book may be 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 the Publisher.
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.
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)
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/javkp9
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Pliki z przykładami omawianymi w książce można znaleźć pod adresem:
ftp://ftp.helion.pl/przyklady/javkp9.zip
Printed in Poland.
• Kup książkę
• Poleć książkę
• Oceń książkę
• Księgarnia internetowa
• Lubię to! » Nasza społeczność
Spis tre(cid:258)ci
O autorze ..................................................................................................................... 23
Przedmowa .................................................................................................................. 25
CZ(cid:125)(cid:165)(cid:109) I
J(cid:218)zyk Java
1 Historia i ewolucja j(cid:218)zyka Java .................................................................................... 31
Rodowód Javy ...................................................................................................................... 31
Narodziny nowoczesnego j(cid:218)zyka — C .......................................................................... 31
J(cid:218)zyk C++ — nast(cid:218)pny krok ....................................................................................... 33
Podwaliny j(cid:218)zyka Java .................................................................................................. 33
Powstanie j(cid:218)zyka Java ........................................................................................................... 33
Powi(cid:200)zanie z j(cid:218)zykiem C# ........................................................................................... 35
Jak j(cid:218)zyk Java zmieni(cid:239) internet .............................................................................................. 35
Aplety Javy ................................................................................................................... 35
Bezpiecze(cid:241)stwo ........................................................................................................... 36
Przeno(cid:258)no(cid:258)(cid:202) ................................................................................................................. 36
Magia j(cid:218)zyka Java — kod bajtowy ........................................................................................ 36
Serwlety — Java po stronie serwera ...................................................................................... 37
Has(cid:239)a j(cid:218)zyka Java .................................................................................................................. 38
Prostota ........................................................................................................................ 38
Obiektowo(cid:258)(cid:202) ................................................................................................................ 38
Niezawodno(cid:258)(cid:202) ............................................................................................................. 38
Wielow(cid:200)tkowo(cid:258)(cid:202) .......................................................................................................... 39
Neutralno(cid:258)(cid:202) architektury .............................................................................................. 39
Interpretowalno(cid:258)(cid:202) i wysoka wydajno(cid:258)(cid:202) ......................................................................... 39
Rozproszenie ............................................................................................................... 39
Dynamika .................................................................................................................... 40
Ewolucja Javy ....................................................................................................................... 40
Java SE 8 ...................................................................................................................... 42
Kultura innowacji ................................................................................................................. 43
Poleć książkęKup książkę4
2
3
Java. Kompendium programisty
Podstawy j(cid:218)zyka Java ................................................................................................... 45
Programowanie obiektowe ................................................................................................... 45
Dwa paradygmaty ........................................................................................................ 45
Abstrakcja ..................................................................................................................... 46
Trzy zasady programowania obiektowego ..................................................................... 46
Pierwszy przyk(cid:239)adowy program ............................................................................................. 50
Wpisanie kodu programu ............................................................................................. 50
Kompilacja programów ................................................................................................. 51
Bli(cid:285)sze spojrzenie na pierwszy przyk(cid:239)adowy program .................................................... 51
Drugi prosty program ............................................................................................................ 53
Dwie instrukcje steruj(cid:200)ce ...................................................................................................... 54
Instrukcja if ................................................................................................................... 54
P(cid:218)tla for ........................................................................................................................ 55
Bloki kodu ............................................................................................................................ 56
Kwestie sk(cid:239)adniowe .............................................................................................................. 58
Znaki bia(cid:239)e ................................................................................................................... 58
Identyfikatory ............................................................................................................... 58
Sta(cid:239)e ............................................................................................................................. 58
Komentarze .................................................................................................................. 58
Separatory .................................................................................................................... 59
S(cid:239)owa kluczowe j(cid:218)zyka Java .......................................................................................... 59
Biblioteki klas Javy ................................................................................................................ 60
Typy danych, zmienne i tablice ................................................................................... 61
Java to j(cid:218)zyk ze (cid:258)cis(cid:239)(cid:200) kontrol(cid:200) typów .................................................................................... 61
Typy proste .......................................................................................................................... 61
Typy ca(cid:239)kowitoliczbowe ....................................................................................................... 62
Typ byte ....................................................................................................................... 62
Typ short ...................................................................................................................... 63
Typ int .......................................................................................................................... 63
Typ long ....................................................................................................................... 63
Typy zmiennoprzecinkowe ................................................................................................... 63
Typ float ....................................................................................................................... 64
Typ double ................................................................................................................... 64
Typ znakowy ........................................................................................................................ 64
Typ logiczny ......................................................................................................................... 66
Bli(cid:285)sze spojrzenie na sta(cid:239)e ..................................................................................................... 66
Sta(cid:239)e ca(cid:239)kowitoliczbowe ............................................................................................... 66
Sta(cid:239)e zmiennoprzecinkowe ........................................................................................... 67
Sta(cid:239)e logiczne ............................................................................................................... 68
Sta(cid:239)e znakowe .............................................................................................................. 68
Sta(cid:239)e (cid:239)a(cid:241)cuchowe ......................................................................................................... 69
Zmienne .............................................................................................................................. 69
Deklaracja zmiennej ..................................................................................................... 69
Inicjalizacja dynamiczna ............................................................................................... 70
Zasi(cid:218)g i czas (cid:285)ycia zmiennych ....................................................................................... 70
Konwersja typów i rzutowanie .............................................................................................. 72
Automatyczna konwersja typów ................................................................................... 72
Rzutowanie niezgodnych typów ................................................................................... 73
Automatyczne rozszerzanie typów w wyra(cid:285)eniach ................................................................ 74
Zasady rozszerzania typu .............................................................................................. 74
Poleć książkęKup książkę
Spis tre(cid:258)ci
5
Tablice ................................................................................................................................. 75
Tablice jednowymiarowe ............................................................................................. 75
Tablice wielowymiarowe .............................................................................................. 77
Alternatywna sk(cid:239)adnia deklaracji tablicy ........................................................................ 80
Kilka s(cid:239)ów o (cid:239)a(cid:241)cuchach ....................................................................................................... 80
Uwaga dla programistów j(cid:218)zyka C lub C++ na temat wska(cid:283)ników ...................................... 81
4 Operatory ..................................................................................................................... 83
Operatory arytmetyczne ....................................................................................................... 83
Podstawowe operatory arytmetyczne ........................................................................... 84
Operator reszty z dzielenia ........................................................................................... 84
Operatory arytmetyczne z przypisaniem ....................................................................... 85
Inkrementacja i dekrementacja .................................................................................... 86
Operatory bitowe ................................................................................................................. 87
Logiczne operatory bitowe ........................................................................................... 88
Przesuni(cid:218)cie w lewo ..................................................................................................... 90
Przesuni(cid:218)cie w prawo .................................................................................................. 91
Przesuni(cid:218)cie w prawo bez znaku .................................................................................. 92
Operatory bitowe z przypisaniem ................................................................................. 93
Operatory relacji .................................................................................................................. 94
Operatory logiczne ............................................................................................................... 95
Operatory logiczne ze skracaniem ................................................................................ 96
Operator przypisania ............................................................................................................ 96
Operator ? ........................................................................................................................... 97
Kolejno(cid:258)(cid:202) wykonywania operatorów .................................................................................... 97
Stosowanie nawiasów okr(cid:200)g(cid:239)ych ........................................................................................... 98
Instrukcje steruj(cid:200)ce ...................................................................................................... 99
Instrukcje wyboru ................................................................................................................. 99
Instrukcja if .................................................................................................................. 99
Instrukcja switch ......................................................................................................... 102
Instrukcje iteracyjne ........................................................................................................... 105
P(cid:218)tla while ................................................................................................................. 106
P(cid:218)tla do-while ............................................................................................................ 107
P(cid:218)tla for ..................................................................................................................... 109
Wersja for-each p(cid:218)tli for ............................................................................................. 112
P(cid:218)tle zagnie(cid:285)d(cid:285)one .................................................................................................... 116
Instrukcje skoku ................................................................................................................. 116
Instrukcja break .......................................................................................................... 117
Instrukcja continue ..................................................................................................... 120
Instrukcja return ......................................................................................................... 121
6 Wprowadzenie do klas .............................................................................................. 123
Klasy .................................................................................................................................. 123
Ogólna posta(cid:202) klasy ................................................................................................... 123
Prosta klasa ................................................................................................................ 124
Deklarowanie obiektów ..................................................................................................... 126
Bli(cid:285)sze spojrzenie na operator new ............................................................................ 127
Przypisywanie zmiennych referencyjnych do obiektów ...................................................... 127
Wprowadzenie do metod .................................................................................................. 128
Dodanie metody do klasy Box .................................................................................... 129
Zwracanie warto(cid:258)ci .................................................................................................... 130
Dodanie metody przyjmuj(cid:200)cej parametry ................................................................... 131
5
Poleć książkęKup książkę6
Java. Kompendium programisty
Konstruktor ......................................................................................................................... 133
Konstruktor sparametryzowany ................................................................................... 134
S(cid:239)owo kluczowe this ........................................................................................................... 135
Ukrywanie zmiennych sk(cid:239)adowych ............................................................................. 135
Mechanizm odzyskiwania pami(cid:218)ci ...................................................................................... 136
Metoda finalize() ................................................................................................................ 136
Klasa stosu .......................................................................................................................... 137
7 Dok(cid:239)adniejsze omówienie metod i klas ..................................................................... 139
Przeci(cid:200)(cid:285)anie metod ............................................................................................................ 139
Przeci(cid:200)(cid:285)anie konstruktorów ........................................................................................ 141
Obiekty jako parametry ...................................................................................................... 143
Dok(cid:239)adniejsze omówienie przekazywania argumentów ...................................................... 145
Zwracanie obiektów ........................................................................................................... 146
Rekurencja ......................................................................................................................... 147
Wprowadzenie do kontroli dost(cid:218)pu .................................................................................... 149
Sk(cid:239)adowe statyczne ............................................................................................................ 152
S(cid:239)owo kluczowe final .......................................................................................................... 153
Powtórka z tablic ................................................................................................................ 154
Klasy zagnie(cid:285)d(cid:285)one i klasy wewn(cid:218)trzne .............................................................................. 155
Omówienie klasy String ...................................................................................................... 157
Wykorzystanie argumentów wiersza polece(cid:241) ...................................................................... 159
Zmienna liczba argumentów .............................................................................................. 160
Przeci(cid:200)(cid:285)anie metod o zmiennej liczbie argumentów ................................................... 162
Zmienna liczba argumentów i niejednoznaczno(cid:258)ci ..................................................... 163
8 Dziedziczenie ............................................................................................................. 165
Podstawy dziedziczenia ...................................................................................................... 165
Dost(cid:218)p do sk(cid:239)adowych a dziedziczenie ....................................................................... 166
Bardziej praktyczny przyk(cid:239)ad ...................................................................................... 167
Zmienna klasy bazowej mo(cid:285)e zawiera(cid:202) referencj(cid:218) do obiektu podklasy ...................... 169
S(cid:239)owo kluczowe super ........................................................................................................ 170
Wykorzystanie s(cid:239)owa kluczowego super do wywo(cid:239)ania konstruktora klasy bazowej ..... 170
Drugie zastosowanie s(cid:239)owa kluczowego super ............................................................ 173
Tworzenie hierarchii wielopoziomowej .............................................................................. 173
Kiedy s(cid:200) wykonywane konstruktory? ................................................................................... 176
Przes(cid:239)anianie metod ........................................................................................................... 177
Dynamiczne przydzielanie metod ....................................................................................... 178
Dlaczego warto przes(cid:239)ania(cid:202) metody? .......................................................................... 180
Zastosowanie przes(cid:239)aniania metod ............................................................................. 180
Klasy abstrakcyjne ............................................................................................................... 181
S(cid:239)owo kluczowe final i dziedziczenie .................................................................................. 184
S(cid:239)owo kluczowe final zapobiega przes(cid:239)anianiu ............................................................ 184
S(cid:239)owo kluczowe final zapobiega dziedziczeniu ........................................................... 184
Klasa Object ....................................................................................................................... 185
Pakiety i interfejsy ...................................................................................................... 187
Pakiety ............................................................................................................................... 187
Definiowanie pakietu ................................................................................................. 187
Znajdowanie pakietów i (cid:258)cie(cid:285)ka CLASSPATH ............................................................. 188
Prosty przyk(cid:239)ad pakietu .............................................................................................. 189
Ochrona dost(cid:218)pu ............................................................................................................... 189
Przyk(cid:239)ad dost(cid:218)pu ........................................................................................................ 190
9
Poleć książkęKup książkę
Spis tre(cid:258)ci
7
Import pakietów ................................................................................................................. 192
Interfejsy ............................................................................................................................ 194
Definiowanie interfejsu .............................................................................................. 194
Implementacja interfejsu ............................................................................................ 195
Interfejsy zagnie(cid:285)d(cid:285)one .............................................................................................. 197
Stosowanie interfejsów ............................................................................................... 198
Zmienne w interfejsach .............................................................................................. 201
Interfejsy mo(cid:285)na rozszerza(cid:202) ........................................................................................ 202
Metody domy(cid:258)lne .............................................................................................................. 203
Podstawy metod domy(cid:258)lnych ..................................................................................... 204
Bardziej praktyczny przyk(cid:239)ad ...................................................................................... 205
Problemy wielokrotnego dziedziczenia ....................................................................... 206
Metody statyczne w interfejsach ......................................................................................... 207
Ostatnie uwagi dotycz(cid:200)ce pakietów i interfejsów ................................................................ 207
10 Obs(cid:239)uga wyj(cid:200)tków ..................................................................................................... 209
Podstawy obs(cid:239)ugi wyj(cid:200)tków ................................................................................................ 209
Typy wyj(cid:200)tków ................................................................................................................... 210
Nieprzechwycone wyj(cid:200)tki .................................................................................................. 210
Stosowanie instrukcji try i catch .......................................................................................... 211
Wy(cid:258)wietlenie opisu wyj(cid:200)tku ....................................................................................... 212
Wiele klauzul catch ............................................................................................................ 213
Zagnie(cid:285)d(cid:285)one instrukcje try ................................................................................................ 214
Instrukcja throw ................................................................................................................. 216
Klauzula throws .................................................................................................................. 217
S(cid:239)owo kluczowe finally ....................................................................................................... 217
Wyj(cid:200)tki wbudowane w j(cid:218)zyk Java ...................................................................................... 219
Tworzenie w(cid:239)asnej podklasy wyj(cid:200)tków ............................................................................... 219
(cid:146)a(cid:241)cuch wyj(cid:200)tków ............................................................................................................. 222
Trzy nowe cechy wyj(cid:200)tków ................................................................................................ 223
Wykorzystanie wyj(cid:200)tków .................................................................................................... 224
11 Programowanie wielow(cid:200)tkowe .................................................................................. 225
Model w(cid:200)tków j(cid:218)zyka Java ................................................................................................. 226
Priorytety w(cid:200)tków ...................................................................................................... 227
Synchronizacja ........................................................................................................... 227
Przekazywanie komunikatów ..................................................................................... 228
Klasa Thread i interfejs Runnable ................................................................................ 228
W(cid:200)tek g(cid:239)ówny .................................................................................................................... 228
Tworzenie w(cid:200)tku ................................................................................................................ 230
Implementacja interfejsu Runnable ............................................................................ 230
Rozszerzanie klasy Thread .......................................................................................... 232
Wybór odpowiedniego podej(cid:258)cia ............................................................................... 232
Tworzenie wielu w(cid:200)tków .................................................................................................... 233
Stosowanie metod isAlive() i join() ...................................................................................... 234
Priorytety w(cid:200)tków .............................................................................................................. 236
Synchronizacja ................................................................................................................... 237
Synchronizacja metod ................................................................................................ 237
Instrukcja synchronized .............................................................................................. 239
Komunikacja mi(cid:218)dzyw(cid:200)tkowa ............................................................................................ 240
Zakleszczenie ............................................................................................................. 244
Zawieszanie, wznawianie i zatrzymywanie w(cid:200)tków ............................................................ 245
Uzyskiwanie stanu w(cid:200)tku ................................................................................................... 247
Korzystanie z wielow(cid:200)tkowo(cid:258)ci ........................................................................................... 249
Poleć książkęKup książkę8
Java. Kompendium programisty
12 Wyliczenia, automatyczne opakowywanie typów prostych i adnotacje (metadane) ... 251
Typy wyliczeniowe ............................................................................................................. 251
Podstawy wylicze(cid:241) ..................................................................................................... 251
Metody values() i valueOf() ......................................................................................... 253
Wyliczenia Javy jako typy klasowe .............................................................................. 254
Wyliczenia dziedzicz(cid:200) po klasie Enum ........................................................................ 256
Inny przyk(cid:239)ad wyliczenia ............................................................................................ 257
Opakowania typów ............................................................................................................ 258
Klasa Character ........................................................................................................... 259
Klasa Boolean ............................................................................................................. 259
Opakowania typów numerycznych ............................................................................ 259
Automatyczne opakowywanie typów prostych .................................................................... 260
Automatyczne opakowywanie i metody ..................................................................... 261
Automatyczne opakowywanie i rozpakowywanie w wyra(cid:285)eniach ............................... 262
Automatyczne opakowywanie typów znakowych i logicznych .................................... 263
Automatyczne opakowywanie pomaga zapobiega(cid:202) b(cid:239)(cid:218)dom ........................................ 264
S(cid:239)owo ostrze(cid:285)enia ....................................................................................................... 264
Adnotacje (metadane) ........................................................................................................ 265
Podstawy tworzenia adnotacji .................................................................................... 265
Okre(cid:258)lanie strategii zachowywania adnotacji .............................................................. 266
Odczytywanie adnotacji w trakcie dzia(cid:239)ania programu za pomoc(cid:200) refleksji ................. 266
Interfejs AnnotatedElement ......................................................................................... 270
Warto(cid:258)ci domy(cid:258)lne ..................................................................................................... 271
Adnotacje znacznikowe .............................................................................................. 272
Adnotacje jednoelementowe ...................................................................................... 272
Wbudowane adnotacje .............................................................................................. 274
Adnotacje typów ................................................................................................................ 275
Adnotacje powtarzalne ....................................................................................................... 279
Ograniczenia .............................................................................................................. 281
13 Wej(cid:258)cie-wyj(cid:258)cie, aplety i inne tematy ........................................................................ 283
Podstawowa obs(cid:239)uga wej(cid:258)cia i wyj(cid:258)cia ................................................................................ 283
Strumienie .................................................................................................................. 284
Strumienie znakowe i bajtowe .................................................................................... 284
Predefiniowane strumienie ......................................................................................... 286
Odczyt danych z konsoli .................................................................................................... 286
Odczyt znaków .......................................................................................................... 286
Odczyt (cid:239)a(cid:241)cuchów ..................................................................................................... 287
Wy(cid:258)wietlanie informacji na konsoli ..................................................................................... 289
Klasa PrintWriter ................................................................................................................. 289
Odczyt i zapis plików ......................................................................................................... 290
Automatyczne zamykanie pliku .......................................................................................... 295
Podstawy apletów .............................................................................................................. 298
Modyfikatory transient i volatile .......................................................................................... 301
Operator instanceof ............................................................................................................ 301
Modyfikator strictfp ............................................................................................................ 303
Metody napisane w kodzie rdzennym ................................................................................ 303
Problemy z metodami rdzennymi ....................................................................................... 306
Stosowanie asercji .............................................................................................................. 306
Opcje w(cid:239)(cid:200)czania i wy(cid:239)(cid:200)czania asercji .......................................................................... 308
Import statyczny ................................................................................................................. 309
Wywo(cid:239)ywanie przeci(cid:200)(cid:285)onych konstruktorów za pomoc(cid:200) this() ............................................ 311
Kompaktowe profile API ..................................................................................................... 313
Poleć książkęKup książkę
Spis tre(cid:258)ci
9
14 Typy sparametryzowane ............................................................................................ 315
Czym s(cid:200) typy sparametryzowane? ...................................................................................... 315
Prosty przyk(cid:239)ad zastosowania typów sparametryzowanych .................................................. 316
Typy sparametryzowane dzia(cid:239)aj(cid:200) tylko dla typów referencyjnych ................................ 319
Typy sparametryzowane ró(cid:285)ni(cid:200) si(cid:218), je(cid:258)li maj(cid:200) inny argument typu .............................. 319
W jaki sposób typy sparametryzowane zwi(cid:218)kszaj(cid:200) bezpiecze(cid:241)stwo? ........................... 319
Klasa sparametryzowana z dwoma parametrami typu ......................................................... 321
Ogólna posta(cid:202) klasy sparametryzowanej ............................................................................. 322
Typy ograniczone ............................................................................................................... 322
Zastosowanie argumentów wieloznacznych ....................................................................... 324
Ograniczony argument wieloznaczny ......................................................................... 327
Tworzenie metody sparametryzowanej .............................................................................. 331
Konstruktory sparametryzowane ................................................................................. 332
Interfejsy sparametryzowane .............................................................................................. 333
Typy surowe i starszy kod ................................................................................................... 335
Hierarchia klas sparametryzowanych .................................................................................. 337
Zastosowanie sparametryzowanej klasy bazowej ........................................................ 337
Podklasa sparametryzowana ....................................................................................... 339
Porównywanie typów w hierarchii klas sparametryzowanych
w czasie wykonywania ............................................................................................ 340
Rzutowanie ................................................................................................................ 342
Przykrywanie metod w klasach sparametryzowanych ................................................. 342
Wnioskowanie typów a typy sparametryzowane ................................................................. 343
Znoszenie .......................................................................................................................... 344
Metody mostu ............................................................................................................ 344
B(cid:239)(cid:218)dy niejednoznaczno(cid:258)ci .................................................................................................. 346
Pewne ograniczenia typów sparametryzowanych ............................................................... 347
Nie mo(cid:285)na tworzy(cid:202) egzemplarza parametru typu ....................................................... 347
Ograniczenia dla sk(cid:239)adowych statycznych .................................................................. 347
Ograniczenia tablic typów sparametryzowanych ........................................................ 347
Ograniczenia wyj(cid:200)tków typów sparametryzowanych .................................................. 348
15 Wyra(cid:285)enia lambda ..................................................................................................... 349
Wprowadzenie do wyra(cid:285)e(cid:241) lambda ................................................................................... 349
Podstawowe informacje o wyra(cid:285)eniach lambda ......................................................... 350
Interfejsy funkcyjne .................................................................................................... 351
Kilka przyk(cid:239)adów wyra(cid:285)e(cid:241) lambda ............................................................................. 352
Blokowe wyra(cid:285)enia lambda ................................................................................................ 354
Sparametryzowane interfejsy funkcyjne .............................................................................. 356
Przekazywanie wyra(cid:285)e(cid:241) lambda jako argumentów ............................................................. 357
Wyra(cid:285)enia lambda i wyj(cid:200)tki ............................................................................................... 360
Wyra(cid:285)enia lambda i przechwytywanie zmiennych .............................................................. 361
Referencje do metod .......................................................................................................... 362
Referencje do metod statycznych ............................................................................... 362
Referencje do metod instancyjnych ............................................................................ 363
Referencje do metod a typy sparametryzowane ......................................................... 366
Referencje do konstruktorów .............................................................................................. 368
Predefiniowane interfejsy funkcyjne ................................................................................... 372
Poleć książkęKup książkę10
Java. Kompendium programisty
CZ(cid:125)(cid:165)(cid:109) II
Biblioteka j(cid:218)zyka Java
16 Obs(cid:239)uga (cid:239)a(cid:241)cuchów ................................................................................................... 377
Konstruktory klasy String ..................................................................................................... 377
D(cid:239)ugo(cid:258)(cid:202) (cid:239)a(cid:241)cucha ............................................................................................................... 379
Specjalne operacje na (cid:239)a(cid:241)cuchach ...................................................................................... 379
Litera(cid:239)y tekstowe ........................................................................................................ 379
Konkatenacja (cid:239)a(cid:241)cuchów ............................................................................................ 380
Konkatenacja (cid:239)a(cid:241)cuchów z innymi typami danych ...................................................... 380
Konwersja (cid:239)a(cid:241)cuchów i metoda toString() ................................................................... 381
Wyodr(cid:218)bnianie znaków ...................................................................................................... 382
Metoda charAt() ......................................................................................................... 382
Metoda getChars() ...................................................................................................... 382
Metoda getBytes() ....................................................................................................... 382
Metoda toCharArray() ................................................................................................. 383
Porównywanie (cid:239)a(cid:241)cuchów .................................................................................................. 383
Metody equals() i equalsIgnoreCase() .......................................................................... 383
Metoda regionMatches() ............................................................................................. 384
Metody startsWith() i endsWith() ................................................................................ 384
Metoda equals() kontra operator == ......................................................................... 384
Metoda compareTo() .................................................................................................. 385
Przeszukiwanie (cid:239)a(cid:241)cuchów ................................................................................................. 386
Modyfikowanie (cid:239)a(cid:241)cucha .................................................................................................... 387
Metoda substring() ...................................................................................................... 387
Metoda concat() ......................................................................................................... 388
Metoda replace() ........................................................................................................ 388
Metoda trim() ............................................................................................................. 389
Konwersja danych za pomoc(cid:200) metody valueOf() ................................................................ 389
Zmiana wielko(cid:258)ci liter w (cid:239)a(cid:241)cuchu ...................................................................................... 390
(cid:146)(cid:200)czenie (cid:239)a(cid:241)cuchów ........................................................................................................... 390
Dodatkowe metody klasy String .......................................................................................... 391
Klasa StringBuffer ................................................................................................................ 391
Konstruktory klasy StringBuffer .................................................................................... 391
Metody length() i capacity() ........................................................................................ 393
Metoda ensureCapacity() ............................................................................................ 393
Metoda setLength() ..................................................................................................... 393
Metody charAt() i setCharAt() ...................................................................................... 393
Metoda getChars() ...................................................................................................... 394
Metoda append() ........................................................................................................ 394
Metoda insert() ........................................................................................................... 395
Metoda reverse() ........................................................................................................ 395
Metody delete() i deleteCharAt() ................................................................................. 395
Metoda replace() ........................................................................................................ 396
Metoda substring() ...................................................................................................... 396
Dodatkowe metody klasy StringBuffer ........................................................................ 397
Klasa StringBuilder .............................................................................................................. 398
17 Pakiet java.lang .......................................................................................................... 399
Opakowania typów prostych .............................................................................................. 399
Klasa Number ............................................................................................................. 400
Klasy Double i Float .................................................................................................... 400
Klasy Byte, Short, Integer i Long .................................................................................. 403
Poleć książkęKup książkę
Spis tre(cid:258)ci
11
Klasa Character .......................................................................................................... 411
Dodatki wprowadzone w celu obs(cid:239)ugi punktów kodowych Unicode .......................... 413
Klasa Boolean ............................................................................................................. 414
Klasa Void .......................................................................................................................... 415
Klasa Process ...................................................................................................................... 415
Klasa Runtime .................................................................................................................... 416
Zarz(cid:200)dzanie pami(cid:218)ci(cid:200) ................................................................................................ 416
Wykonywanie innych programów .............................................................................. 418
Klasa ProcessBuilder ........................................................................................................... 419
Klasa System ...................................................................................................................... 421
Wykorzystanie metody currentTimeMillis() do obliczania czasu wykonywania programu ... 422
U(cid:285)ycie metody arraycopy() ......................................................................................... 423
W(cid:239)a(cid:258)ciwo(cid:258)ci (cid:258)rodowiska ............................................................................................. 424
Klasa Object ....................................................................................................................... 424
Wykorzystanie metody clone() i interfejsu Cloneable .......................................................... 425
Klasa Class .......................................................................................................................... 426
Klasa ClassLoader ............................................................................................................... 429
Klasa Math ......................................................................................................................... 429
Funkcje trygonometryczne ......................................................................................... 429
Funkcje wyk(cid:239)adnicze .................................................................................................. 430
Funkcje zaokr(cid:200)gle(cid:241) .................................................................................................... 430
Inne metody klasy Math ............................................................................................. 430
Klasa StrictMath ................................................................................................................. 433
Klasa Compiler ................................................................................................................... 433
Klasy Thread i ThreadGroup oraz interfejs Runnable .......................................................... 433
Interfejs Runnable ...................................................................................................... 433
Klasa Thread .............................................................................................................. 433
Klasa ThreadGroup .................................................................................................... 435
Klasy ThreadLocal i InheritableThreadLocal ........................................................................ 439
Klasa Package ..................................................................................................................... 439
Klasa RuntimePermission .................................................................................................... 439
Klasa Throwable ................................................................................................................. 439
Klasa SecurityManager ........................................................................................................ 439
Klasa StackTraceElement .................................................................................................... 439
Klasa Enum ........................................................................................................................ 441
Klasa ClassValue ................................................................................................................. 442
Interfejs CharSequence ...................................................................................................... 442
Interfejs Comparable .......................................................................................................... 442
Interfejs Appendable .......................................................................................................... 442
Interfejs Iterable ................................................................................................................. 443
Interfejs Readable ............................................................................................................... 443
Interfejs AutoCloseable ....................................................................................................... 443
Interfejs Thread.UncaughtExceptionHandler ...................................................................... 444
Podpakiety pakietu java.lang .............................................................................................. 444
Podpakiet java.lang.annotation ................................................................................... 444
Podpakiet java.lang.instrument ................................................................................... 444
Podpakiet java.lang.invoke ......................................................................................... 444
Podpakiet java.lang.management ............................................................................... 444
Podpakiet java.lang.ref ............................................................................................... 445
Podpakiet java.lang.reflect .......................................................................................... 445
Poleć książkęKup książkę12
Java. Kompendium programisty
18 Pakiet java.util, cz(cid:218)(cid:258)(cid:202) 1. — kolekcje .......................................................................... 447
Wprowadzenie do kolekcji ................................................................................................. 448
Zmiany w kolekcjach wprowadzone w JDK 5 ..................................................................... 449
Typy sparametryzowane w znacz(cid:200)cy sposób zmieniaj(cid:200) kolekcje ................................. 449
Automatyczne opakowywanie u(cid:239)atwia korzystanie z typów prostych ........................... 450
P(cid:218)tla for typu for-each ................................................................................................ 450
Interfejsy kolekcji ................................................................................................................ 450
Interfejs Collection ..................................................................................................... 451
Interfejs List ................................................................................................................ 453
Interfejs Set ................................................................................................................ 454
Interfejs SortedSet ...................................................................................................... 454
Interfejs NavigableSet ................................................................................................. 455
Interfejs Queue .......................................................................................................... 455
Interfejs Deque ........................................................................................................... 455
Klasy kolekcji ...................................................................................................................... 458
Klasa ArrayList ............................................................................................................ 458
Klasa LinkedList .......................................................................................................... 461
Klasa HashSet ............................................................................................................. 462
Klasa LinkedHashSet ................................................................................................... 463
Klasa TreeSet .............................................................................................................. 464
Klasa PriorityQueue .................................................................................................... 465
Klasa ArrayDeque ....................................................................................................... 465
Klasa EnumSet ............................................................................................................ 466
Dost(cid:218)p do kolekcji za pomoc(cid:200) iteratora .............................................................................. 466
Korzystanie z iteratora Iterator .................................................................................... 468
P(cid:218)tla typu for-each jako alternatywa dla iteratora ........................................................ 469
Spliteratory ......................................................................................................................... 470
Przechowywanie w kolekcjach w(cid:239)asnych klas ...................................................................... 473
Interfejs RandomAccess ...................................................................................................... 474
Korzystanie z map .............................................................................................................. 474
Interfejsy map ............................................................................................................. 474
Klasy map ................................................................................................................... 479
Komparatory ...................................................................................................................... 483
Wykorzystanie komparatora ....................................................................................... 485
Algorytmy kolekcji .............................................................................................................. 490
Klasa Arrays ........................................................................................................................ 495
Starsze klasy i interfejsy ....................................................................................................... 499
Interfejs Enumeration ................................................................................................. 499
Klasa Vector ............................................................................................................... 500
Klasa Stack ................................................................................................................. 503
Klasa Dictionary ......................................................................................................... 504
Klasa Hashtable .......................................................................................................... 505
Klasa Properties .......................................................................................................... 508
Wykorzystanie metod store() i load() ........................................................................... 510
Ostatnie uwagi na temat kolekcji ........................................................................................ 512
19 Pakiet java.util, cz(cid:218)(cid:258)(cid:202) 2. — pozosta(cid:239)e klasy u(cid:285)ytkowe .............................................. 513
Klasa StringTokenizer .......................................................................................................... 513
Klasa BitSet ......................................................................................................................... 514
Klasy Optional, OptionalDouble, OptionalInt oraz OptionalLong ....................................... 517
Klasa Date .......................................................................................................................... 519
Klasa Calendar .................................................................................................................... 521
Klasa GregorianCalendar .................................................................................................... 524
Klasa TimeZone .................................................................................................................. 525
Poleć książkęKup książkę
Spis tre(cid:258)ci
13
Klasa SimpleTimeZone ....................................................................................................... 525
Klasa Locale ....................................................................................................................... 527
Klasa Random ......................
Pobierz darmowy fragment (pdf)
Gdzie kupić całą publikację:
Opinie na temat publikacji:
Inne popularne pozycje z tej kategorii:
Czytaj również:
Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką :