Niemal od chwili swojego powstania Java jest jednym z najważniejszych i najpopularniejszych języków programowania. Dzieje się tak dzięki konsekwentnemu rozwijaniu tego języka i poszukiwaniu coraz to nowszych technologii. Sprawia to, że Java jest pierwszym i najlepszym wyborem dla programistów zainteresowanych tworzeniem aplikacji internetowych. Oprócz tego nadaje się do wielu innych zastosowań. Łatwo się można przekonać, że większość współczesnego świata korzysta z kodu Javy. Dotyczy to nie tylko komputerów czy smartfonów, ale także ogromnej liczby różnych innych urządzeń.
Ta książka jest X wydaniem znakomitego podręcznika, w pełni zaktualizowanym o informacje dotyczące Java SE 9 . W przystępny sposób wyjaśniono tu, jak pisać, kompilować, debugować i uruchamiać kod Javy. Znalazły się tu także informacje o kluczowych elementach biblioteki Java API , takich jak obsługa wejścia-wyjścia, Collections Framework, biblioteka strumieni oraz narzędzia do programowania współbieżnego. W praktyczny sposób przedstawiono bibliotekę Swing, JavaFX, technologię JavaBeans oraz serwletów. Książka zawiera także szczegółowy opis modułów i praktyczne wprowadzenie do JShell, narzędzia do interaktywnego programowania w Javie.
Najważniejsze zagadnienia ujęte w książce:
typy danych, zmienne, tablice i operatory oraz instrukcje sterujące
programowanie obiektowe i dziedziczenie
interfejsy i pakiety oraz obsługa wyjątków
programowanie wielowątkowe
wyrażenia lambda, moduły, programowanie sieciowe
obsługa zdarzeń i programowanie współbieżne
Java. Klasyka w programowaniu!
Znajdź podobne książki
Ostatnio czytane w tej kategorii
Darmowy fragment publikacji:
Tytuł oryginału: Java™: The Complete Reference, Tenth Edition
Tłumaczenie: Piotr Rajca oraz Mikołaj Szczepaniak (fragmenty pochodzące z „Java. Kompendium
programisty. Wydanie VIII”
ISBN: 978-83-283-4613-0
Original edition copyright © 2018 by McGraw-Hill Education (Publisher)
All rights reserved.
Polish edition copyright © 2018 by Helion SA
All rights reserved.
Oracle and Java are registered trademarks of Oracle Corporation and/or its affiliates. All other
trademarks are the property of their respective owners, and McGraw-Hill Education makes no claim of
ownership by the mention of products that contain these marks.
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 Helion SA 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 Helion SA nie ponoszą również
żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych
w książce.
Helion SA
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/javk10
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/javk10.zip
Printed in Poland.
• Kup książkę
• Poleć książkę
• Oceń książkę
• Księgarnia internetowa
• Lubię to! » Nasza społeczność
Spis treści
O autorze ............................................................................................................................. 25
Przedmowa .......................................................................................................................... 27
CZĘŚĆ I
Język Java
1 Historia i ewolucja języka Java .................................................................................... 33
Rodowód Javy ...................................................................................................................... 33
Narodziny nowoczesnego języka — C .......................................................................... 33
Język C++ — następny krok ....................................................................................... 35
Podwaliny języka Java .................................................................................................. 35
Powstanie języka Java ........................................................................................................... 35
Powiązanie z językiem C# ........................................................................................... 37
Jak Java wywarła wpływ na internet ...................................................................................... 37
Aplety Javy ................................................................................................................... 37
Bezpieczeństwo ........................................................................................................... 38
Przenośność ................................................................................................................. 38
Magia języka Java — kod bajtowy ........................................................................................ 39
Wychodząc poza aplety ....................................................................................................... 40
Serwlety — Java po stronie serwera ...................................................................................... 40
Hasła języka Java .................................................................................................................. 40
Prostota ........................................................................................................................ 41
Obiektowość ................................................................................................................ 41
Niezawodność ............................................................................................................. 41
Wielowątkowość .......................................................................................................... 42
Neutralność architektury .............................................................................................. 42
Interpretowalność i wysoka wydajność ......................................................................... 42
Rozproszenie ............................................................................................................... 42
Dynamika .................................................................................................................... 42
Ewolucja Javy ....................................................................................................................... 43
Java SE 9 .............................................................................................................................. 46
Kultura innowacji ................................................................................................................. 46
Poleć książkęKup książkę4
2
3
Java. Kompendium programisty
Podstawy języka Java ................................................................................................... 47
Programowanie obiektowe ................................................................................................... 47
Dwa paradygmaty ........................................................................................................ 47
Abstrakcja ..................................................................................................................... 48
Trzy zasady programowania obiektowego ..................................................................... 48
Pierwszy przykładowy program ............................................................................................. 52
Wpisanie kodu programu ............................................................................................. 52
Kompilacja programów ................................................................................................. 53
Bliższe spojrzenie na pierwszy przykładowy program .................................................... 53
Drugi prosty program ............................................................................................................ 55
Dwie instrukcje sterujące ...................................................................................................... 56
Instrukcja if ................................................................................................................... 56
Pętla for ........................................................................................................................ 58
Bloki kodu ............................................................................................................................ 59
Kwestie składniowe .............................................................................................................. 60
Znaki białe ................................................................................................................... 60
Identyfikatory ............................................................................................................... 60
Stałe ............................................................................................................................. 60
Komentarze .................................................................................................................. 61
Separatory .................................................................................................................... 61
Słowa kluczowe języka Java .......................................................................................... 61
Biblioteki klas Javy ................................................................................................................ 62
Typy danych, zmienne i tablice ................................................................................... 63
Java to język ze ścisłą kontrolą typów .................................................................................... 63
Typy proste .......................................................................................................................... 63
Typy całkowitoliczbowe ....................................................................................................... 64
Typ byte ....................................................................................................................... 64
Typ short ...................................................................................................................... 65
Typ int .......................................................................................................................... 65
Typ long ....................................................................................................................... 65
Typy zmiennoprzecinkowe ................................................................................................... 65
Typ float ....................................................................................................................... 66
Typ double ................................................................................................................... 66
Typ znakowy ........................................................................................................................ 66
Typ logiczny ......................................................................................................................... 68
Bliższe spojrzenie na stałe ..................................................................................................... 68
Stałe całkowitoliczbowe ............................................................................................... 68
Stałe zmiennoprzecinkowe ........................................................................................... 69
Stałe logiczne ............................................................................................................... 70
Stałe znakowe .............................................................................................................. 70
Stałe łańcuchowe ......................................................................................................... 71
Zmienne .............................................................................................................................. 71
Deklaracja zmiennej ..................................................................................................... 71
Inicjalizacja dynamiczna ............................................................................................... 72
Zasięg i czas życia zmiennych ....................................................................................... 72
Konwersja typów i rzutowanie .............................................................................................. 74
Automatyczna konwersja typów ................................................................................... 74
Rzutowanie niezgodnych typów ................................................................................... 75
Automatyczne rozszerzanie typów w wyrażeniach ................................................................ 76
Zasady rozszerzania typu .............................................................................................. 76
Tablice ................................................................................................................................. 77
Tablice jednowymiarowe .............................................................................................. 77
Tablice wielowymiarowe .............................................................................................. 79
Alternatywna składnia deklaracji tablicy ........................................................................ 82
Kilka słów o łańcuchach ........................................................................................................ 83
Poleć książkęKup książkę
Spis treści
5
5
4 Operatory ..................................................................................................................... 85
Operatory arytmetyczne ....................................................................................................... 85
Podstawowe operatory arytmetyczne ........................................................................... 86
Operator reszty z dzielenia ........................................................................................... 86
Operatory arytmetyczne z przypisaniem ....................................................................... 87
Inkrementacja i dekrementacja .................................................................................... 88
Operatory bitowe ................................................................................................................. 89
Logiczne operatory bitowe ........................................................................................... 90
Przesunięcie w lewo ..................................................................................................... 92
Przesunięcie w prawo .................................................................................................. 93
Przesunięcie w prawo bez znaku .................................................................................. 94
Operatory bitowe z przypisaniem ................................................................................. 95
Operatory relacji .................................................................................................................. 96
Operatory logiczne ............................................................................................................... 97
Operatory logiczne ze skracaniem ................................................................................ 98
Operator przypisania ............................................................................................................ 99
Operator ? ........................................................................................................................... 99
Kolejność wykonywania operatorów .................................................................................. 100
Stosowanie nawiasów okrągłych ......................................................................................... 100
Instrukcje sterujące .................................................................................................... 103
Instrukcje wyboru ............................................................................................................... 103
Instrukcja if ................................................................................................................ 103
Instrukcja switch ......................................................................................................... 106
Instrukcje iteracyjne ........................................................................................................... 109
Pętla while ................................................................................................................. 110
Pętla do-while ............................................................................................................ 111
Pętla for ..................................................................................................................... 113
Wersja for-each pętli for ............................................................................................. 116
Pętle zagnieżdżone .................................................................................................... 120
Instrukcje skoku ................................................................................................................. 121
Instrukcja break .......................................................................................................... 121
Instrukcja continue ..................................................................................................... 124
Instrukcja return ......................................................................................................... 125
6 Wprowadzenie do klas .............................................................................................. 127
Klasy .................................................................................................................................. 127
Ogólna postać klasy ................................................................................................... 127
Prosta klasa ................................................................................................................ 128
Deklarowanie obiektów ..................................................................................................... 130
Bliższe spojrzenie na operator new ............................................................................ 131
Przypisywanie zmiennych referencyjnych do obiektów ...................................................... 131
Wprowadzenie do metod .................................................................................................. 132
Dodanie metody do klasy Box .................................................................................... 132
Zwracanie wartości .................................................................................................... 134
Dodanie metody przyjmującej parametry ................................................................... 135
Konstruktor ........................................................................................................................ 137
Konstruktor sparametryzowany ................................................................................... 138
Słowo kluczowe this ........................................................................................................... 139
Ukrywanie zmiennych składowych ............................................................................. 139
Mechanizm odzyskiwania pamięci ..................................................................................... 140
Klasa stosu .......................................................................................................................... 140
Poleć książkęKup książkę6
Java. Kompendium programisty
7 Dokładniejsze omówienie metod i klas ..................................................................... 143
Przeciążanie metod ............................................................................................................ 143
Przeciążanie konstruktorów ........................................................................................ 145
Obiekty jako parametry ...................................................................................................... 147
Dokładniejsze omówienie przekazywania argumentów ...................................................... 149
Zwracanie obiektów ........................................................................................................... 150
Rekurencja ......................................................................................................................... 151
Wprowadzenie do kontroli dostępu .................................................................................... 153
Składowe statyczne ............................................................................................................ 156
Słowo kluczowe final .......................................................................................................... 157
Powtórka z tablic ................................................................................................................ 158
Klasy zagnieżdżone i klasy wewnętrzne .............................................................................. 159
Omówienie klasy String ...................................................................................................... 162
Wykorzystanie argumentów wiersza poleceń ...................................................................... 163
Zmienna liczba argumentów .............................................................................................. 164
Przeciążanie metod o zmiennej liczbie argumentów ................................................... 167
Zmienna liczba argumentów i niejednoznaczności ..................................................... 168
8 Dziedziczenie ............................................................................................................. 171
Podstawy dziedziczenia ...................................................................................................... 171
Dostęp do składowych a dziedziczenie ....................................................................... 172
Bardziej praktyczny przykład ...................................................................................... 173
Zmienna klasy bazowej może zawierać referencję do obiektu klasy pochodnej .......... 175
Słowo kluczowe super ........................................................................................................ 176
Wykorzystanie słowa kluczowego super do wywołania konstruktora klasy bazowej ..... 176
Drugie zastosowanie słowa kluczowego super ............................................................ 179
Tworzenie hierarchii wielopoziomowej .............................................................................. 180
Kiedy są wykonywane konstruktory? ................................................................................... 182
Przesłanianie metod ........................................................................................................... 183
Dynamiczne przydzielanie metod ....................................................................................... 185
Dlaczego warto przesłaniać metody? .......................................................................... 186
Zastosowanie przesłaniania metod ............................................................................. 186
Klasy abstrakcyjne ............................................................................................................... 188
Słowo kluczowe final i dziedziczenie .................................................................................. 190
Słowo kluczowe final zapobiega przesłanianiu ............................................................ 190
Słowo kluczowe final zapobiega dziedziczeniu ........................................................... 191
Klasa Object ....................................................................................................................... 191
Pakiety i interfejsy ...................................................................................................... 193
Pakiety ............................................................................................................................... 193
Definiowanie pakietu ................................................................................................. 193
Znajdowanie pakietów i ścieżka CLASSPATH ............................................................. 194
Prosty przykład pakietu .............................................................................................. 195
Dostęp do pakietów i składowych ...................................................................................... 195
Przykład dostępu ........................................................................................................ 196
Import pakietów ................................................................................................................. 199
Interfejsy ............................................................................................................................ 200
Definiowanie interfejsu .............................................................................................. 201
Implementacja interfejsu ............................................................................................ 202
Interfejsy zagnieżdżone .............................................................................................. 204
Stosowanie interfejsów ............................................................................................... 205
Zmienne w interfejsach .............................................................................................. 207
Interfejsy można rozszerzać ........................................................................................ 209
9
Poleć książkęKup książkę
Spis treści
7
Metody domyślne .............................................................................................................. 210
Podstawy metod domyślnych ..................................................................................... 211
Bardziej praktyczny przykład ...................................................................................... 212
Problemy wielokrotnego dziedziczenia ....................................................................... 213
Metody statyczne w interfejsach ......................................................................................... 213
Stosowanie metod prywatnych w interfejsach ..................................................................... 214
Ostatnie uwagi dotyczące pakietów i interfejsów ................................................................ 215
10 Obsługa wyjątków ..................................................................................................... 217
Podstawy obsługi wyjątków ................................................................................................ 217
Typy wyjątków ................................................................................................................... 218
Nieprzechwycone wyjątki .................................................................................................. 218
Stosowanie instrukcji try i catch .......................................................................................... 219
Wyświetlenie opisu wyjątku ....................................................................................... 220
Wiele klauzul catch ............................................................................................................ 221
Zagnieżdżone instrukcje try ................................................................................................ 222
Instrukcja throw ................................................................................................................. 224
Klauzula throws .................................................................................................................. 225
Słowo kluczowe finally ....................................................................................................... 225
Wyjątki wbudowane w język Java ...................................................................................... 227
Tworzenie własnej klasy pochodnej wyjątków .................................................................... 227
Łańcuch wyjątków ............................................................................................................. 230
Trzy dodatkowe cechy wyjątków ........................................................................................ 231
Wykorzystanie wyjątków .................................................................................................... 232
11 Programowanie wielowątkowe .................................................................................. 233
Model wątków języka Java ................................................................................................. 234
Priorytety wątków ...................................................................................................... 235
Synchronizacja ........................................................................................................... 235
Przekazywanie komunikatów ..................................................................................... 236
Klasa Thread i interfejs Runnable ................................................................................ 236
Wątek główny .................................................................................................................... 236
Tworzenie wątku ................................................................................................................ 238
Implementacja interfejsu Runnable ............................................................................ 238
Rozszerzanie klasy Thread .......................................................................................... 240
Wybór odpowiedniego podejścia ............................................................................... 240
Tworzenie wielu wątków .................................................................................................... 241
Stosowanie metod isAlive() i join() ...................................................................................... 242
Priorytety wątków .............................................................................................................. 244
Synchronizacja ................................................................................................................... 245
Synchronizacja metod ................................................................................................ 245
Instrukcja synchronized .............................................................................................. 247
Komunikacja międzywątkowa ............................................................................................ 248
Zakleszczenie ............................................................................................................. 252
Zawieszanie, wznawianie i zatrzymywanie wątków ............................................................ 254
Uzyskiwanie stanu wątku ................................................................................................... 256
Stosowanie metody wytwórczej do tworzenia i uruchamiania wątku .................................. 257
Korzystanie z wielowątkowości ........................................................................................... 258
12 Wyliczenia, automatyczne opakowywanie typów prostych i adnotacje ................... 259
Typy wyliczeniowe ............................................................................................................. 259
Podstawy wyliczeń ..................................................................................................... 259
Metody values() i valueOf() ......................................................................................... 261
Wyliczenia Javy jako typy klasowe .............................................................................. 262
Poleć książkęKup książkę8
Java. Kompendium programisty
Wyliczenia dziedziczą po klasie Enum ........................................................................ 264
Inny przykład wyliczenia ............................................................................................ 265
Opakowania typów ............................................................................................................ 267
Klasa Character ........................................................................................................... 267
Klasa Boolean ............................................................................................................. 267
Opakowania typów numerycznych ............................................................................ 268
Automatyczne opakowywanie typów prostych .................................................................... 269
Automatyczne opakowywanie i metody ..................................................................... 270
Automatyczne opakowywanie i rozpakowywanie w wyrażeniach ............................... 270
Automatyczne opakowywanie typów znakowych i logicznych .................................... 272
Automatyczne opakowywanie pomaga zapobiegać błędom ........................................ 272
Słowo ostrzeżenia ....................................................................................................... 273
Adnotacje ........................................................................................................................... 273
Podstawy tworzenia adnotacji .................................................................................... 274
Określanie strategii zachowywania adnotacji .............................................................. 274
Odczytywanie adnotacji w trakcie działania programu za pomocą refleksji ................. 275
Interfejs AnnotatedElement ......................................................................................... 279
Wartości domyślne ..................................................................................................... 279
Adnotacje znacznikowe .............................................................................................. 281
Adnotacje jednoelementowe ...................................................................................... 281
Wbudowane adnotacje .............................................................................................. 283
Adnotacje typów ................................................................................................................ 284
Adnotacje powtarzalne ....................................................................................................... 288
Ograniczenia ...................................................................................................................... 290
13 Wejście-wyjście, instrukcja try z zasobami i inne tematy ......................................... 291
Podstawowa obsługa wejścia i wyjścia ................................................................................ 291
Strumienie .................................................................................................................. 292
Strumienie znakowe i bajtowe .................................................................................... 292
Predefiniowane strumienie ......................................................................................... 294
Odczyt danych z konsoli .................................................................................................... 294
Odczyt znaków .......................................................................................................... 294
Odczyt łańcuchów ..................................................................................................... 295
Wyświetlanie informacji na konsoli ..................................................................................... 297
Klasa PrintWriter ................................................................................................................. 297
Odczyt i zapis plików ......................................................................................................... 298
Automatyczne zamykanie pliku .......................................................................................... 303
Modyfikatory transient i volatile .......................................................................................... 306
Operator instanceof ............................................................................................................ 307
Modyfikator strictfp ............................................................................................................ 309
Metody napisane w kodzie rdzennym ................................................................................ 309
Stosowanie asercji .............................................................................................................. 309
Opcje włączania i wyłączania asercji .......................................................................... 311
Import statyczny ................................................................................................................. 312
Wywoływanie przeciążonych konstruktorów za pomocą this() ............................................ 314
Kilka słów o kompaktowych profilach API ........................................................................... 316
14 Typy sparametryzowane ............................................................................................ 317
Czym są typy sparametryzowane? ....................................................................................... 317
Prosty przykład zastosowania typów sparametryzowanych .................................................. 318
Typy sparametryzowane działają tylko dla typów referencyjnych ................................ 321
Typy sparametryzowane różnią się, jeśli mają inny argument typu .............................. 321
W jaki sposób typy sparametryzowane zwiększają bezpieczeństwo? ........................... 321
Poleć książkęKup książkę
Spis treści
9
Klasa sparametryzowana z dwoma parametrami typu ......................................................... 323
Ogólna postać klasy sparametryzowanej ............................................................................. 324
Typy ograniczone ............................................................................................................... 324
Zastosowanie argumentów wieloznacznych ....................................................................... 326
Ograniczony argument wieloznaczny ......................................................................... 329
Tworzenie metody sparametryzowanej .............................................................................. 333
Konstruktory sparametryzowane ................................................................................. 334
Interfejsy sparametryzowane .............................................................................................. 335
Typy surowe i starszy kod ................................................................................................... 337
Hierarchia klas sparametryzowanych .................................................................................. 339
Zastosowanie sparametryzowanej klasy bazowej ........................................................ 339
Podklasa sparametryzowana ....................................................................................... 341
Porównywanie typów w hierarchii klas sparametryzowanych w czasie wykonywania ..... 342
Rzutowanie ................................................................................................................ 344
Przesłanianie metod w klasach sparametryzowanych .................................................. 344
Wnioskowanie typów a typy sparametryzowane ................................................................. 345
Znoszenie .......................................................................................................................... 346
Metody mostu ............................................................................................................ 346
Błędy niejednoznaczności .................................................................................................. 348
Pewne ograniczenia typów sparametryzowanych ............................................................... 349
Nie można tworzyć egzemplarza parametru typu ....................................................... 349
Ograniczenia dla składowych statycznych .................................................................. 349
Ograniczenia tablic typów sparametryzowanych ........................................................ 349
Ograniczenia wyjątków typów sparametryzowanych .................................................. 350
15 Wyrażenia lambda ..................................................................................................... 351
Wprowadzenie do wyrażeń lambda ................................................................................... 351
Podstawowe informacje o wyrażeniach lambda ......................................................... 352
Interfejsy funkcyjne .................................................................................................... 352
Kilka przykładów wyrażeń lambda ............................................................................. 353
Blokowe wyrażenia lambda ................................................................................................ 356
Sparametryzowane interfejsy funkcyjne .............................................................................. 358
Przekazywanie wyrażeń lambda jako argumentów ............................................................. 359
Wyrażenia lambda i wyjątki ............................................................................................... 362
Wyrażenia lambda i przechwytywanie zmiennych .............................................................. 363
Referencje do metod .......................................................................................................... 364
Referencje do metod statycznych ............................................................................... 364
Referencje do metod instancyjnych ............................................................................ 365
Referencje do metod a typy sparametryzowane ......................................................... 368
Referencje do konstruktorów .............................................................................................. 370
Predefiniowane interfejsy funkcyjne ................................................................................... 374
16 Moduły ....................................................................................................................... 377
Podstawowe informacje o modułach .................................................................................. 377
Przykład prostego modułu .......................................................................................... 378
Kompilowanie i uruchamianie przykładowej aplikacji ................................................. 382
Dokładniejsze informacje o instrukcjach requires i exports ......................................... 383
java.base i moduły platformy .............................................................................................. 384
Stary kod i moduł nienazwany ........................................................................................... 384
Eksportowanie do konkretnego modułu ............................................................................. 385
Wymagania przechodnie .................................................................................................... 386
Stosowanie usług ................................................................................................................ 390
Podstawowe informacje o usługach i dostawcach usług .............................................. 390
Słowa kluczowe związane z usługami ......................................................................... 391
Przykład stosowania usług i modułów ......................................................................... 391
Poleć książkęKup książkę10
Java. Kompendium programisty
Grafy modułów .................................................................................................................. 397
Trzy wyspecjalizowane cechy modułów ............................................................................. 398
Moduły otwarte .......................................................................................................... 398
Instrukcja opens ......................................................................................................... 398
Instrukcja requires static ............................................................................................. 398
Wprowadzenie do jlink i plików JAR modułów ................................................................... 399
Dołączanie plików dostarczonych jako struktura katalogów ........................................ 399
Konsolidacja modularnych plików JAR ........................................................................ 399
Pliki JMOD ................................................................................................................. 400
Kilka słów o warstwach i modułach automatycznych .......................................................... 400
Końcowe uwagi dotyczące modułów .................................................................................. 401
CZĘŚĆ II
Biblioteka języka Java
17 Obsługa łańcuchów ................................................................................................... 405
Konstruktory klasy String ..................................................................................................... 405
Długość łańcucha ............................................................................................................... 407
Specjalne operacje na łańcuchach ...................................................................................... 407
Literały tekstowe ........................................................................................................ 407
Konkatenacja łańcuchów ............................................................................................ 408
Konkatenacja łańcuchów z innymi typami danych ...................................................... 408
Konwersja łańcuchów i metoda toString() ................................................................... 409
Wyodrębnianie znaków ...................................................................................................... 410
Metoda charAt() ......................................................................................................... 410
Metoda getChars() ...................................................................................................... 410
Metoda getBytes() ....................................................................................................... 410
Metoda toCharArray() ................................................................................................. 411
Porównywanie łańcuchów .................................................................................................. 411
Metody equals() i equalsIgnoreCase() .......................................................................... 411
Metoda regionMatches() ............................................................................................. 412
Metody startsWith() i endsWith() ................................................................................ 412
Metoda equals() kontra operator == ......................................................................... 412
Metoda compareTo() .................................................................................................. 413
Przeszukiwanie łańcuchów ................................................................................................. 414
Modyfikowanie łańcucha .................................................................................................... 415
Metoda substring() ...................................................................................................... 415
Metoda concat() ......................................................................................................... 416
Metoda replace() ........................................................................................................ 416
Metoda trim() ............................................................................................................. 417
Konwersja danych za pomocą metody valueOf() ................................................................ 417
Zmiana wielkości liter w łańcuchu ...................................................................................... 418
Łączenie łańcuchów ........................................................................................................... 419
Dodatkowe metody klasy String .......................................................................................... 419
Klasa StringBuffer ................................................................................................................ 419
Konstruktory klasy StringBuffer .................................................................................... 420
Metody length() i capacity() ........................................................................................ 421
Metoda ensureCapacity() ............................................................................................ 421
Metoda setLength() ..................................................................................................... 421
Metody charAt() i setCharAt() ...................................................................................... 422
Metoda getChars() ...................................................................................................... 422
Metoda append() ........................................................................................................ 422
Metoda insert() ........................................................................................................... 423
Poleć książkęKup książkę
Spis treści
11
Metoda reverse() ........................................................................................................ 423
Metody delete() i deleteCharAt() ................................................................................ 424
Metoda replace() ........................................................................................................ 424
Metoda substring() ...................................................................................................... 425
Dodatkowe metody klasy StringBuffer ........................................................................ 425
Klasa StringBuilder .............................................................................................................. 426
18 Pakiet java.lang .......................................................................................................... 427
Opakowania typów prostych .............................................................................................. 427
Klasa Number ............................................................................................................ 428
Klasy Double i Float ................................................................................................... 428
Metody isInfinite() i isNan() ........................................................................................ 431
Klasy Byte, Short, Integer i Long ................................................................................. 431
Klasa Character .......................................................................................................... 439
Dodatki wprowadzone w celu obsługi punktów kodowych Unicode .......................... 440
Klasa Boolean ............................................................................................................. 443
Klasa Void .......................................................................................................................... 443
Klasa Process ...................................................................................................................... 444
Klasa Runtime .................................................................................................................... 445
Zarządzanie pamięcią ................................................................................................ 446
Wykonywanie innych programów .............................................................................. 447
Runtime.Version ................................................................................................................ 447
Klasa ProcessBuilder ........................................................................................................... 448
Klasa System ...................................................................................................................... 450
Wykorzystanie metody currentTimeMillis()
do obliczania czasu wykonywania programu ........................................................... 452
Użycie metody arraycopy() ......................................................................................... 452
Właściwości środowiska ............................................................................................. 453
Interfejs System.Logger i klasa System.LoggerFinder ............................................................ 453
Klasa Object ....................................................................................................................... 453
Wykorzystanie metody clone() i interfejsu Cloneable .......................................................... 454
Klasa Class .......................................................................................................................... 456
Klasa ClassLoader ............................................................................................................... 458
Klasa Math ......................................................................................................................... 458
Funkcje trygonometryczne ......................................................................................... 458
Funkcje wykładnicze .................................................................................................. 459
Funkcje zaokrągleń .................................................................................................... 459
Inne metody klasy Math ............................................................................................. 461
Klasa StrictMath ................................................................................................................. 462
Klasa Compiler ................................................................................................................... 463
Klasy Thread i ThreadGroup oraz interfejs Runnable .......................................................... 463
Interfejs Runnable ...................................................................................................... 463
Klasa Thread .............................................................................................................. 463
Klasa ThreadGroup .................................................................................................... 465
Klasy ThreadLocal i InheritableThreadLocal ........................................................................ 469
Klasa Package ..................................................................................................................... 469
Klasa Module ..................................................................................................................... 469
Klasa ModuleLayer ............................................................................................................. 471
Klasa RuntimePermission .................................................................................................... 471
Klasa Throwable ................................................................................................................. 471
Klasa SecurityManager ........................................................................................................ 471
Klasa StackTraceElement .................................................................................................... 471
Klasa StackWalker i interfejs StackWalker.StackFrame ........................................................ 471
Klasa Enum ........................................................................................................................ 471
Poleć książkęKup książkę12
Java. Kompendium programisty
Klasa ClassValue ................................................................................................................. 473
Interfejs CharSequence ....................................................................................................... 473
Interfejs Comparable .......................................................................................................... 473
Interfejs Appendable .......................................................................................................... 473
Interfejs Iterable .................................................................................................................. 474
Interfejs Readable ............................................................................................................... 474
Interfejs AutoCloseable ....................................................................................................... 474
Interfejs Thread.UncaughtExceptionHandler ....................................................................... 475
Podpakiety pakietu java.lang .............................................................................................. 475
Podpakiet java.lang.annotation ................................................................................... 475
Podpakiet java.lang.instrument ................................................................................... 475
Podpakiet java.lang.invoke ......................................................................................... 475
Podpakiet java.lang.module ........................................................................................ 475
Podpakiet java.lang.management ............................................................................... 476
Podpakiet java.lang.ref ............................................................................................... 476
Podpakiet java.lang.reflect .......................................................................................... 476
19 Pakiet java.util, część 1. — kolekcje .......................................................................... 477
Wprowadzenie do kolekcji ................................................................................................. 478
Interfejsy kolekcji ................................................................................................................ 479
Interfejs Collection ..................................................................................................... 480
Interfejs List ................................................................................................................ 482
Interfejs Set ................................................................................................................ 483
Interfejs SortedSet ...................................................................................................... 484
Interfejs NavigableSet ................................................................................................. 484
Interfejs Queue .......................................................................................................... 485
Interfejs Deque ........................................................................................................... 486
Klasy kolekcji ...................................................................................................................... 487
Klasa ArrayList ............................................................................................................ 488
Klasa LinkedList .......................................................................................................... 491
Klasa HashSet ............................................................................................................. 492
Klasa LinkedHashSet ................................................................................................... 493
Klasa TreeSet .............................................................................................................. 493
Klasa PriorityQueue .................................................................................................... 495
Klasa ArrayDeque ....................................................................................................... 495
Klasa EnumSet ............................................................................................................ 496
Dostęp do kolekcji za pomocą iteratora .............................................................................. 496
Korzystanie z iteratora Iterator .................................................................................... 498
Pętla typu for-each jako alternatywa dla iteratora ........................................................ 499
Spliteratory ......................................................................................................................... 500
Przechowywanie w kolekcjach własnych klas ...................................................................... 503
Interfejs RandomAccess ...................................................................................................... 504
Korzystanie z map .............................................................................................................. 504
Interfejsy map ............................................................................................................. 504
Klasy map ................................................................................................................... 510
Komparatory ...................................................................................................................... 514
Wykorzystanie komparatora ....................................................................................... 516
Algorytmy kolekcji .............................................................................................................. 520
Klasa Arrays ........................................................................................................................ 525
Starsze klasy i interfejsy ....................................................................................................... 529
Interfejs Enumeration ................................................................................................. 529
Klasa Vector ............................................................................................................... 530
Klasa Stack ................................................................................................................. 533
Klasa Dictionary ......................................................................................................... 534
Poleć książkęKup książkę
Spis treści
13
Klasa Hashtable .......................................................................................................... 535
Klasa Properties .......................................................................................................... 538
Wykorzystanie metod store() i load() .......................................................................... 541
Ostatnie uwagi na temat kolekcji ........................................................................................ 542
20 Pakiet java.util, część 2. — pozostałe klasy użytkowe ...................................
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ą :