Popularność języka Java stale rośnie. Programiści z całego świata wykorzystują go do tworzenia zarówno prostych aplikacji, jak i złożonych systemów. Podstawowa zaleta Javy -- przenośność kodu -- powoduje, że programy napisane w Javie możemy spotkać nie tylko na dyskach komputerów i serwerów, ale również w telefonach komórkowych i innych urządzeniach mobilnych. Java jest ciągle rozwijana -- w każdej kolejnej wersji pojawiają się nowe elementy, ułatwiające realizację coraz bardziej złożonych zagadnień programistycznych.
'Java. Kompendium programisty' to doskonały przewodnik po najnowszym wcieleniu języka Java, noszącym oznaczenie J2SE5. Każdy twórca aplikacji w Javie znajdzie tu niezbędne do swojej pracy informacje. Autor -- Herb Schildt, znany z wielu bestsellerowych pozycji dotyczących programowania w Javie i C++ -- opisuje wszystkie elementy języka Java w wersji 5. Typy danych, metody, konstrukcje, podstawowe biblioteki i techniki programistyczne -- wszystko zostało opisane prostym i zrozumiałym językiem oraz zilustrowane przykładami.
Historia języka Java
Podstawowe założenia programowania obiektowego
Typy danych i zmienne
Operatory
Klasy, metody, pakiety i interfejsy
Wątki i wyjątki
Elementy bibliotek Javy
Operacje wejścia i wyjścia
Programowanie sieciowe
Biblioteki AWT i Swing
JavaBeans i serwlety
W tym podręczniku znajdziesz odpowiedzi na wszystkie pytania związane z Javą.
O autorze:
Herb Schildt jest autorytetem w sprawach języków C, C++, Java i C#, a także doskonałym programistą systemu Windows.
[więcej...\
Znajdź podobne książki
Ostatnio czytane w tej kategorii
Darmowy fragment publikacji:
IDZ DO
IDZ DO
PRZYK£ADOWY ROZDZIA£
PRZYK£ADOWY ROZDZIA£
SPIS TREĎCI
SPIS TREĎCI
KATALOG KSI¥¯EK
KATALOG KSI¥¯EK
KATALOG ONLINE
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
TWÓJ KOSZYK
DODAJ DO KOSZYKA
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
ZAMÓW INFORMACJE
O NOWOĎCIACH
O NOWOĎCIACH
ZAMÓW CENNIK
ZAMÓW CENNIK
CZYTELNIA
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
Java. Kompendium
programisty
Autor: Herbert Schildt
T³umaczenie: Rafa³ Joñca, Miko³aj
Szczepaniak, Jakub Thiele-Wieczorek
ISBN: 83-7361-862-7
Tytu³ orygina³u: Java: The Complete Reference,
J2SE 5 Edition (Complete Reference)
Format: B5, stron: 1112
Popularnoġæ jêzyka Java stale roġnie. Programiġci z ca³ego ġwiata wykorzystuj¹ go
do tworzenia zarówno prostych aplikacji, jak i z³o¿onych systemów. Podstawowa zaleta
Javy — przenoġnoġæ kodu — powoduje, ¿e programy napisane w Javie mo¿emy spotkaæ
nie tylko na dyskach komputerów i serwerów, ale równie¿ w telefonach komórkowych
i innych urz¹dzeniach mobilnych. Java jest ci¹gle rozwijana — w ka¿dej kolejnej wersji
pojawiaj¹ siê nowe elementy, u³atwiaj¹ce realizacjê coraz bardziej z³o¿onych zagadnieñ
programistycznych.
„Java. Kompendium programisty” to doskona³y przewodnik po najnowszym wcieleniu
jêzyka Java, nosz¹cym oznaczenie J2SE5. Ka¿dy twórca aplikacji w Javie znajdzie tu
niezbêdne do swojej pracy informacje. Autor — Herb Schildt, znany z wielu best-
sellerowych pozycji dotycz¹cych programowania w Javie i C++ — opisuje wszystkie
elementy jêzyka Java w wersji 5. Typy danych, metody, konstrukcje, podstawowe
biblioteki i techniki programistyczne — wszystko zosta³o opisane prostym i zrozumia³ym
jêzykiem oraz zilustrowane przyk³adami.
• Historia jêzyka Java
• Podstawowe za³o¿enia programowania obiektowego
• Typy danych i zmienne
• Operatory
• Klasy, metody, pakiety i interfejsy
• W¹tki i wyj¹tki
• Elementy bibliotek Javy
• Operacje wejġcia i wyjġcia
• Programowanie sieciowe
• Biblioteki AWT i Swing
• JavaBeans i serwlety
W tym podrêczniku znajdziesz odpowiedzi na wszystkie pytania zwi¹zane z Jav¹.
Spis treści
O Autorze ........................................................................................ 21
Przedmowa ...................................................................................... 23
Część I
Język Java ...................................................k..................27
Rozdział 1. Historia i ewolucja języka Java ......................................................... 29
Rodowód Javy ...................................................y...................................................y.......... 29
Narodziny nowoczesnego języka — C ...................................................y.................. 30
Język C++ — następny krok ...................................................y................................. 31
Podwaliny języka Java ...................................................y.......................................... 32
Powstanie języka Java ...................................................y................................................. 32
Powiązanie z językiem C# ...................................................y.................................... 34
Dlaczego język Java jest tak ważny dla internetu ...................................................y........ 35
Aplety Javy ...................................................y...................................................y........ 35
Bezpieczeństwo ...................................................y...................................................y.. 36
Przenośność ...................................................y...................................................y........ 36
Magia języka Java — kod bajtowy ...................................................y.............................. 36
Hasła języka Java ...................................................y...................................................y..... 37
Prostota ...................................................y...................................................y.............. 38
Obiektowość ..................................................y...................................................y........ 38
Solidność ...................................................y...................................................y............ 38
Wielowątkowość ...................................................y...................................................y 39
Neutralność architektury ...................................................y....................................... 39
Interpretowalność i wysoka wydajność ...................................................y................. 40
Rozproszenie ...................................................y...................................................y...... 40
Dynamika ...................................................y...................................................y........... 40
Ewolucja Javy ...................................................y...................................................y.......... 40
Rewolucja J2SE 5 ..................................................y...................................................y...... 41
Kultura innowacji ...................................................y...................................................y..... 42
Rozdział 2. Podstawy języka Java ...................................................................... 43
Programowanie obiektowe ...................................................y.......................................... 43
Dwa paradygmaty ...................................................y................................................. 43
Abstrakcja ...................................................y...................................................y.......... 44
Trzy zasady programowania obiektowego ...................................................y............ 44
Pierwszy przykładowy program ...................................................y.................................. 49
Wpisanie kodu programu ...................................................y...................................... 50
Kompilacja programów ...................................................y......................................... 50
Bliższe spojrzenie na pierwszy przykładowy program ............................................. 51
4
Java. Kompendium programisty
Drugi prosty program ...................................................y.................................................. 53
Dwie instrukcje sterujące ...................................................y............................................ 55
Instrukcja if ...................................................y...................................................y........ 55
Pętla for ...................................................y...................................................y.............. 57
Bloki kodu ...................................................y...................................................y................ 58
Kwestie leksykalne ...................................................y...................................................y... 59
Znaki niedrukowane ...................................................y.............................................. 60
Identyfikatory ...................................................y...................................................y..... 60
Literał ...................................................y...................................................y.................60
Komentarze ...................................................y...................................................y........ 60
Separatory ...................................................y...................................................y.......... 61
Słowa kluczowe języka Java ...................................................y................................. 61
Biblioteki klas Javy ...................................................y...................................................y.. 62
Rozdział 3. Typy danych, zmienne i tablice ......................................................... 63
Java to język ze ścisłą kontrolą typów ...................................................y......................... 63
Typy proste ...................................................y...................................................y............... 63
Typy całkowite ...................................................y...................................................y......... 64
Typ byte ...................................................y...................................................y............. 65
Typ short ...................................................y...................................................y............ 65
Typ int ...................................................y...................................................y................ 66
Typ long ...................................................y...................................................y............. 66
Typy zmiennoprzecinkowe ...................................................y......................................... 67
Typ float ...................................................y...................................................y............. 67
Typ double ...................................................y...................................................y......... 67
Typ znakowy ...................................................y...................................................y............ 68
Typ logiczny ...................................................y...................................................y............. 69
Bliższe spojrzenie na literały ...................................................y....................................... 70
Literały będące liczbami całkowitymi ...................................................y................... 70
Literały zmiennoprzecinkowe ...................................................y............................... 71
Literały logiczne ..................................................y...................................................y.. 71
Literały znakowe ...................................................y...................................................y 71
Literały tekstowe ...................................................y...................................................y 72
Zmienne ............................................y...................................................y........................... 72
Deklaracja zmiennej ...................................................y.............................................. 73
Inicjalizacja dynamiczna ...................................................y....................................... 73
Zasięg i czas życia zmiennych ...................................................y.............................. 74
Konwersja typów i rzutowanie ...................................................y.................................... 76
Automatyczna konwersja typów ...................................................y........................... 76
Rzutowanie dla typów niezgodnych ...................................................y...................... 77
Automatyczne rozszerzanie typów w wyrażeniach ...................................................y..... 78
Zasady rozszerzania typu ...................................................y...................................... 79
Tablice ...................................................y...................................................y...................... 80
Tablice jednowymiarowe ...................................................y...................................... 80
Tablice wielowymiarowe ...................................................y...................................... 83
Alternatywna składnia deklaracji tablicy ...................................................y.............. 86
Kilka słów na temat ciągów znaków ...................................................y........................... 87
Uwaga dla programistów języka C lub C++ na temat wskaźników ................................ 87
Rozdział 4. Operatory ........................................................................................ 89
Operatory arytmetyczne ...................................................y.............................................. 89
Podstawowe operatory arytmetyczne ...................................................y.................... 89
Operator reszty z dzielenia ...................................................y.................................... 91
Operatory arytmetyczne z przypisaniem ...................................................y............... 91
Inkrementacja i dekrementacja ...................................................y.............................. 92
Spis treści
5
Operatory bitowe ...................................................y...................................................y...... 94
Podstawowe operatory bitowe ...................................................y............................... 95
Przesunięcie w lewo ...................................................y.............................................. 97
Przesunięcie w prawo ...................................................y............................................ 99
Przesunięcie w prawo bez znaku ...................................................y......................... 100
Operatory bitowe z przypisaniem ...................................................y........................ 102
Operatory relacji ...................................................y...................................................y..... 103
Operatory logiczne ...................................................y...................................................y. 104
Operatory logiczne ze skracaniem ...................................................y....................... 105
Operator przypisania ...................................................y................................................. 106
Operator ?: ...................................................y...................................................y.............. 106
Kolejność wykonywania operatorów ...................................................y........................ 107
Wykorzystanie nawiasów okrągłych ...................................................y......................... 107
Rozdział 5. Struktury sterujące ........................................................................ 109
Instrukcje wyboru ...................................................y...................................................y... 109
Konstrukcja if ...................................................y...................................................y... 109
Konstrukcja switch ...................................................y.............................................. 112
Instrukcje iteracji ...................................................y...................................................y.... 116
Pętla while ...................................................y...................................................y........ 116
Pętla do-while ...................................................y...................................................y.. 118
Pętla for ...................................................y...................................................y............ 121
Wersja for-each pętli for ...................................................y..................................... 124
Pętle zagnieżdżone ...................................................y.............................................. 129
Instrukcje skoku ...................................................y...................................................y..... 130
Instrukcja break ...................................................y...................................................y 130
Instrukcja continue ...................................................y.............................................. 134
Instrukcja return ...................................................y.................................................. 135
Rozdział 6. Wprowadzenie do klas ................................................................... 137
Klasy ...................................................y...................................................y...................... 137
Ogólna postać klasy ...................................................y............................................ 137
Prosta klasa ...................................................y...................................................y...... 139
Tworzenie obiektów ...................................................y.................................................. 141
Bliższe spojrzenie na klasę ...................................................y.................................. 142
Przypisywanie zmiennych referencyjnych do obiektów ............................................... 143
Metody ...................................................y...................................................y................... 144
Dodanie metody do klasy Box ...................................................y............................ 145
Zwracanie wartości ...................................................y............................................. 146
Dodanie metody przyjmującej parametry ...................................................y............ 148
Konstruktor ...................................................y...................................................y............ 150
Konstruktor sparametryzowany ...................................................y.......................... 152
Słowo kluczowe this ...................................................y.................................................. 153
Ukrywanie zmiennych składowych ...................................................y..................... 153
Mechanizm odzyskiwania pamięci ...................................................y............................ 154
Metoda finalize() ...................................................y...................................................y.... 154
Klasa stosu ...................................................y...................................................y.............155
Rozdział 7. Dokładniejsze omówienie metod i klas ........................................... 159
Przeciążanie metod ...................................................y...................................................y. 159
Przeciążanie konstruktorów ...................................................y................................ 162
Obiekty jako parametry ...................................................y............................................. 164
Dokładniejsze omówienie przekazywania argumentów ............................................... 166
Zwracanie obiektów ...................................................y.................................................. 168
Rekurencja ...................................................y...................................................y..............169
6
Java. Kompendium programisty
Wprowadzenie do sterowania dostępem ...................................................y.................... 171
Składowe statyczne ...................................................y...................................................y 175
Słowo kluczowe final ...................................................y................................................ 177
Powtórka z tablic ...................................................y...................................................y.... 177
Klasy zagnieżdżone i klasy wewnętrzne ...................................................y..................... 179
Omówienie klasy String ...................................................y............................................ 182
Wykorzystanie argumentów wiersza poleceń ...................................................y............ 184
Zmienna liczba argumentów ...................................................y..................................... 185
Przeciążanie metod o zmiennej liczbie argumentów .............................................. 188
Zmienna liczba argumentów i niejednoznaczności ................................................ 189
Rozdział 8. Dziedziczenie ................................................................................. 191
Proste dziedziczenie ...................................................y.................................................. 191
Dostęp do składowych a dziedziczenie ...................................................y............... 193
Bardziej praktyczny przykład ...................................................y.............................. 194
Zmienna klasy bazowej może zawierać referencję do obiektu podklasy ................ 196
Słowo kluczowe super ...................................................y............................................... 197
Wykorzystanie słowa kluczowego super
do wywołania konstruktora klasy bazowej ...................................................y....... 197
Drugie zastosowanie słowa kluczowego super ..................................................y..... 200
Tworzenie hierarchii wielopoziomowej ...................................................y.................... 201
Kiedy dochodzi do wywołania konstruktorów? ...................................................y........ 204
Przesłanianie metod ...................................................y...................................................y 205
Dynamiczne przydzielanie metod ...................................................y............................. 208
Dlaczego warto przesłaniać metody? ...................................................y.................. 209
Zastosowanie przesłaniania metod ...................................................y...................... 210
Klasy abstrakcyjne ...................................................y...................................................y. 211
Słowo kluczowe final i dziedziczenie ...................................................y........................ 214
Słowo kluczowe final zapobiega przesłanianiu ...................................................y... 214
Słowo kluczowe final zapobiega dziedziczeniu ...................................................y.. 215
Klasa Object ...................................................y...................................................y........... 215
Rozdział 9. Pakiety i interfejsy ......................................................................... 217
Pakiety ...................................................y...................................................y.................... 217
Definiowanie pakietu ...................................................y.......................................... 218
Znajdowanie pakietów i ścieżka CLASSPATH ...................................................y.. 219
Prosty przykład pakietu ...................................................y....................................... 219
Ochrona dostępu ...................................................y...................................................y..... 220
Przykład dostępu ...................................................y................................................. 221
Import pakietów ...................................................y...................................................y..... 224
Interfejsy ...................................................y...................................................y................ 226
Definiowanie interfejsu ...................................................y....................................... 227
Implementacja interfejsu ...................................................y..................................... 227
Zastosowanie interfejsów ...................................................y.................................... 230
Zmienne w interfejsach ...................................................y....................................... 233
Interfejsy można rozszerzać ...................................................y................................ 235
Rozdział 10. Obsługa wyjątków .......................................................................... 237
Podstawy obsługi wyjątków ...................................................y...................................... 237
Typy wyjątków ...................................................y...................................................y....... 238
Nieprzechwycone wyjątki ...................................................y......................................... 238
Wykorzystanie konstrukcji try i catch ...................................................y....................... 240
Wyświetlenie opisu wyjątku ...................................................y............................... 241
Wiele klauzul catch ...................................................y...................................................y 241
Zagnieżdżone konstrukcje try ...................................................y.................................... 243
Spis treści
7
Instrukcja throw ...................................................y...................................................y...... 245
Klauzula throws ...................................................y...................................................y...... 246
Słowo kluczowe finally ...................................................y............................................. 248
Wyjątki wbudowane w język Java ...................................................y............................ 249
Tworzenie własnej podklasy wyjątków ...................................................y..................... 250
Łańcuch wyjątków ...................................................y...................................................y. 252
Wykorzystanie wyjątków ...................................................y.......................................... 254
Rozdział 11. Programowanie wielowątkowe ....................................................... 255
Model wątków języka Java ...................................................y....................................... 256
Priorytety wątków ...................................................y............................................... 257
Synchronizacja ...................................................y...................................................y. 257
Przekazywanie komunikatów ...................................................y.............................. 258
Klasa Thread i interfejs Runnable ...................................................y....................... 258
Wątek główny ...................................................y...................................................y........ 259
Tworzenie wątku ...................................................y...................................................y.... 261
Implementacja interfejsu Runnable ...................................................y..................... 261
Rozszerzanie klasy Thread ...................................................y.................................. 263
Wybór odpowiedniego podejścia ...................................................y........................ 264
Tworzenie wielu wątków ...................................................y.......................................... 264
Wykorzystanie metod isAlive() oraz join() ...................................................y............... 266
Priorytety wątków ...................................................y...................................................y.. 268
Synchronizacja ...................................................y...................................................y....... 271
Synchronizacja metod ...................................................y......................................... 271
Konstrukcja synchronized ...................................................y................................... 274
Komunikacja międzywątkowa ...................................................y.................................. 275
Blokada wzajemna ...................................................y.............................................. 279
Zawieszanie, wznawianie i zatrzymywanie wątków ...................................................y. 281
Zawieszanie, wznawianie i zatrzymywanie wątków w Java 1.1 lub starszej ......... 282
Nowoczesny sposób zawieszania, wznawiania i zatrzymywania wątków ............. 284
Korzystanie z wielowątkowości ...................................................y................................ 286
Rozdział 12. Wyliczenia, automatyczne otaczanie typów prostych i metadane .... 287
Wyliczenia ...................................................y...................................................y..............287
Podstawy wyliczeń ...................................................y.............................................. 288
Metody values() i valueOf() ...................................................y................................ 290
Wyliczenia Javy jako typ klasy ...................................................y........................... 291
Wyliczenia dziedziczą po klasie Enum ...................................................y............... 293
Inny przykład wyliczenia ...................................................y.................................... 295
Typy otoczkowe ...................................................y...................................................y..... 296
Automatyczne otaczanie typów prostych ...................................................y.................. 298
Automatyczne otaczanie i metody ..................................................y........................ 299
Automatyczne otaczanie i rozpakowywanie w wyrażeniach .................................. 300
Automatyczne otaczanie dla typów znakowych i logicznych ................................ 302
Automatyczne otaczanie pomaga zapobiegać błędom .............................................. 303
Słowo ostrzeżenia ...................................................y............................................... 303
Metadane (notatki) ...................................................y...................................................y. 304
Podstawy tworzenia notatek ...................................................y................................ 304
Określenie strategii zachowania ...................................................y.......................... 305
Pobieranie notatek w trakcie działania programu dzięki refleksji .......................... 306
Interfejs AnnotatedElement ...................................................y................................. 310
Wartości domyślne ...................................................y.............................................. 311
Notatki znacznikowe ...................................................y........................................... 312
Notatki jednoelementowe ...................................................y.................................... 313
Wbudowane notatki ...................................................y............................................ 315
Ograniczenia ...................................................y...................................................y.... 316
8
Java. Kompendium programisty
Rozdział 13. Wejście-wyjście, aplety i inne tematy ............................................ 317
Podstawowa obsługa wejścia i wyjścia ...................................................y..................... 317
Strumienie ...................................................y...................................................y........ 318
Strumienie znakowe i bajtowe ...................................................y............................ 318
Predefiniowane strumienie ...................................................y.................................. 319
Odczyt danych z konsoli ...................................................y........................................... 321
Odczyt znaków ...................................................y...................................................y. 321
Odczyt ciągów znaków ...................................................y....................................... 322
Wyświetlanie informacji na konsoli ...................................................y.......................... 324
Klasa PrintWriter ...................................................y...................................................y.... 324
Odczyt i zapis plików ...................................................y................................................ 325
Podstawy apletów ...................................................y...................................................y... 328
Modyfikatory transient i volatile ...................................................y............................... 331
Operator instanceof ...................................................y...................................................y 332
Modyfikator strictfp ...................................................y.................................................. 334
Metody napisane w kodzie rdzennym ...................................................y....................... 335
Problemy z metodami rdzennymi ...................................................y........................ 338
Asercja ..................................................y...................................................y..................... 338
Opcje włączania i wyłączania asercji ...................................................y.................. 341
Import statyczny ...................................................y...................................................y..... 341
Rozdział 14. Typy sparametryzowane ................................................................. 345
Czym są typy sparametryzowane? ..................................................y.............................. 346
Prosty przykład zastosowania typów sparametryzowanych ......................................... 346
Typy sparametryzowane działają tylko dla obiektów ............................................. 350
Typy sparametryzowane różnią się, jeśli mają inny argument typu ....................... 350
W jaki sposób typy sparametryzowane zwiększają bezpieczeństwo? .................... 350
Klasa sparametryzowana z dwoma parametrami typu .................................................. 353
Ogólna postać klasy sparametryzowanej ...................................................y................... 354
Typy ograniczone ...................................................y...................................................y... 354
Zastosowanie argumentów wieloznacznych ...................................................y.............. 357
Ograniczony argument wieloznaczny ...................................................y................. 359
Tworzenie metody sparametryzowanej ...................................................y..................... 364
Konstruktory sparametryzowane ...................................................y......................... 366
Interfejsy sparametryzowane ...................................................y..................................... 367
Typy surowe i dotychczasowy kod ...................................................y........................... 369
Hierarchia klas sparametryzowanych ...................................................y........................ 372
Zastosowanie sparametryzowanej klasy bazowej ..................................................y. 372
Podklasa sparametryzowana ..................................................y................................. 374
Porównywanie typów w trakcie działania programu
dla hierarchii klas sparametryzowanych ...................................................y........... 375
Rzutowanie ...................................................y...................................................y...... 378
Przesłanianie metod w klasach sparametryzowanych ............................................ 378
Znoszenie ...................................................y...................................................y...............379
Metody mostu ...................................................y...................................................y.. 381
Błędy niejednoznaczności ...................................................y......................................... 383
Pewne ograniczenia typów sparametryzowanych ..................................................y....... 384
Nie można tworzyć egzemplarza parametru typu .................................................. 384
Ograniczenia dla składowych statycznych ...................................................y.......... 385
Ograniczenia tablic typów sparametryzowanych ...................................................y 385
Ograniczenia wyjątków typów sparametryzowanych ............................................ 386
Ostatnie uwagi na temat typów sparametryzowanych .................................................. 387
Spis treści
9
Cześć II Biblioteka języka Java .................................................389
Rozdział 15. Ciągi znaków ................................................................................. 391
Konstruktory klasy String ..................................................y........................................... 392
Konstruktory dodane w wydaniu J2SE 5 ...................................................y............ 394
Długość ciągu znaków ...................................................y............................................... 394
Specjalne operacje na ciągach znaków ...................................................y...................... 394
Literały tekstowe ...................................................y................................................. 395
Konkatenacja ciągów znaków ...................................................y............................. 395
Konkatenacja ciągu znaków z innymi typami danych ............................................ 396
Konwersja do ciągu znaków i metoda toString() ...................................................y 396
Wydobycie znaków ...................................................y...................................................y 397
Metoda charAt() ...................................................y.................................................. 398
Metoda getChars() ...................................................y............................................... 398
Metoda getBytes() ...................................................y............................................... 399
Metoda toCharArray() ...................................................y......................................... 399
Porównywanie ciągów znaków ...................................................y................................. 399
Metody equals() i equalsIgnoreCase() ...................................................y................. 399
Metoda regionMatches() ...................................................y..................................... 400
Metody startsWith() i endsWith() ...................................................y....................... 401
Metoda equals() a operator == ...................................................y............................ 401
Metoda compareTo() ...................................................y........................................... 402
Wyszukiwanie podciągów znaków ...................................................y............................ 403
Modyfikacja ciągu znaków ...................................................y........................................ 405
Metoda substring() ...................................................y.............................................. 405
Metoda concat() ...................................................y.................................................. 406
Metoda replace() ...................................................y................................................. 406
Metoda trim() ...................................................y...................................................y... 407
Konwersja danych za pomocą metody valueOf() ...................................................y...... 408
Zmiana wielkości liter ciągu znaków ...................................................y........................ 408
Dodatkowe metody klasy String ...................................................y................................ 409
Klasa StringBuffer ...................................................y...................................................y.. 409
Konstruktory klasy StringBuffer ...................................................y......................... 411
Metody length() i capacity() ...................................................y................................ 411
Metoda ensureCapacity() ...................................................y.................................... 412
Metoda setLength() ...................................................y............................................. 412
Metody charAt() i setCharAt() ...................................................y............................ 412
Metoda getChars() ...................................................y............................................... 413
Metoda append() ...................................................y................................................. 413
Metoda insert() ...................................................y...................................................y. 414
Metoda reverse() ...................................................y................................................. 414
Metody delete() i deleteCharAt() ...................................................y........................ 415
Metoda replace() ...................................................y................................................. 416
Metoda substring() ...................................................y.............................................. 416
Dodatkowe metody klasy StringBuffer ...................................................y............... 416
Klasa StringBuilder ...................................................y...................................................y 418
Rozdział 16. Pakiet java.lang ............................................................................. 419
Otoczki typów prostych ...................................................y............................................. 420
Klasa Number ...................................................y...................................................y.. 420
Klasy Double i Float ...................................................y........................................... 420
Klasy Byte, Short, Integer i Long ...................................................y........................ 424
Klasa Character ...................................................y...................................................y 432
Dodatki wprowadzone w celu obsługi rozszerzonych znaków Unicode ................ 434
Klasa Boolean ...................................................y...................................................y.. 435
10
Java. Kompendium programisty
Klasa Void ...................................................y...................................................y..............435
Klasa Process ...................................................y...................................................y......... 436
Klasa Runtime ...................................................y...................................................y........ 437
Zarządzanie pamięcią ...................................................y.......................................... 438
Wykonywanie innych programów ...................................................y...................... 440
Klasa ProcessBuilder ...................................................y................................................. 441
Klasa System ...................................................y...................................................y.......... 442
Wykorzystanie metody currentTimeMillis()
do obliczania czasu wykonywania programu ...................................................y... 444
Użycie metody arraycopy() ...................................................y................................. 445
Właściwości środowiska ...................................................y..................................... 446
Klasa Object ...................................................y...................................................y........... 446
Wykorzystanie metody clone() i interfejsu Cloneable .................................................. 446
Klasa Class ...................................................y...................................................y.............449
Klasa ClassLoader ...................................................y...................................................y.. 452
Klasa Math ...................................................y...................................................y............. 452
Funkcje trygonometryczne ...................................................y.................................. 452
Funkcje wykładnicze ...................................................y........................................... 453
Funkcje zaokrągleń ...................................................y............................................. 453
Różnorodne metody klasy Math ...................................................y.......................... 454
Klasa StrictMath ...................................................y...................................................y..... 455
Klasa Compiler ...................................................y...................................................y....... 455
Klasy Thread i ThreadGroup oraz interfejs Runnable .................................................. 455
Interfejs Runnable ...................................................y............................................... 456
Klasa Thread ...................................................y...................................................y.... 456
Klasa ThreadGroup ...................................................y............................................. 458
Klasy ThreadLocal i InheritableThreadLocal ...................................................y............ 462
Klasa Package ...................................................y...................................................y........ 463
Klasa RuntimePermission ...................................................y......................................... 463
Klasa Throwable ...................................................y...................................................y.... 463
Klasa SecurityManager ...................................................y............................................. 463
Klasa StackTraceElement ...................................................y.......................................... 464
Klasa Enum ...................................................y...................................................y............ 465
Interfejs CharSequence ...................................................y.............................................. 466
Interfejs Comparable ...................................................y................................................. 467
Interfejs Appendable ...................................................y................................................. 467
Interfejs Iterable ...................................................y...................................................y..... 467
Interfejs Readable ...................................................y...................................................y... 468
Podpakiety pakietu java.lang ...................................................y..................................... 468
Podpakiet java.lang.annotation ...................................................y........................... 468
Podpakiet java.lang.instrument ...................................................y........................... 469
Podpakiet java.lang.management ...................................................y........................ 469
Podpakiet java.lang.ref ...................................................y........................................ 469
Podpakiet java.lang.reflect ...................................................y.................................. 469
Rozdział 17. Pakiet java.util, część 1. — kolekcje ............................................ 471
Wprowadzenie do kolekcji ...................................................y........................................ 472
Zmiany w kolekcjach spowodowane wydaniem J2SE 5 .............................................. 473
Typy sparametryzowane w znaczący sposób zmieniają kolekcje ........................... 473
Automatyczne otaczanie ułatwia korzystanie z typów prostych ............................ 474
Pętla for typu for-each ...................................................y......................................... 474
Interfejsy kolekcji ...................................................y...................................................y... 474
Interfejs Collection ...................................................y.............................................. 475
Interfejs List ...................................................y...................................................y..... 477
Spis treści
11
Interfejs Set ...................................................y...................................................y...... 478
Interfejs SortedSet ...................................................y............................................... 479
Interfejs Queue ...................................................y...................................................y. 479
Klasy kolekcji ...................................................y...................................................y......... 480
Klasa ArrayList ...................................................y...................................................y 481
Klasa LinkedList ...................................................y................................................. 484
Klasa HashSet ...................................................y...................................................y.. 486
Klasa LinkedHashSet ...................................................y.......................................... 488
Klasa TreeSet ...................................................y...................................................y... 488
Klasa PriorityQueue ...................................................y............................................ 489
Klasa EnumSet ...................................................y...................................................y. 490
Dostęp do kolekcji za pomocą iteratora ...................................................y..................... 490
Korzystanie z iteratora Iterator ...................................................y............................ 492
Pętla typu for-each jako alternatywa dla iteratora .................................................. 494
Przechowywanie w kolekcjach własnych klas ..................................................y............ 495
Interfejs RandomAccess ...................................................y............................................ 496
Korzystanie z map ...................................................y...................................................y.. 496
Interfejsy map ...................................................y...................................................y.. 497
Klasy map ...................................................y...................................................y........ 499
Komparatory ..................................................y...................................................y............ 505
Wykorzystanie komparatora ..................................................y................................. 505
Algorytmy kolekcji ..................................................y...................................................y.. 508
Klasa Arrays ...................................................y...................................................y........... 513
Dlaczego kolekcje są sparametryzowane? ...................................................y................. 516
Starsze klasy i interfejsy ...................................................y............................................ 519
Interfejs wyliczeń ...................................................y................................................ 520
Klasa Vector ...................................................y...................................................y..... 520
Klasa Stack ...................................................y...................................................y....... 524
Klasa Dictionary ..................................................y...................................................y 526
Klasa Hashtable ...................................................y...................................................y 527
Klasa Properties ...................................................y.................................................. 530
Wykorzystanie metod store() i load() ...................................................y.................. 533
Ostatnie uwagi na temat kolekcji ...................................................y............................... 535
Rozdział 18. Pakiet java.util, część 2. — pozostałe klasy użytkowe ................... 537
Klasa StringTokenizer ...................................................y............................................... 537
Klasa BitSet ...................................................y...................................................y............539
Klasa Date ...................................................y...................................................y..............542
Klasa Calendar ...................................................y...................................................y....... 543
Klasa GregorianCalendar ...................................................y.......................................... 546
Klasa TimeZone ...................................................y...................................................y..... 548
Klasa SimpleTimeZone ...................................................y............................................. 548
Klasa Locale ...................................................y...................................................y........... 550
Klasa Random ...................................................y...................................................y........ 551
Klasa Observable ...................................................y...................................................y.... 553
Interfejs Observer ...................................................y................................................ 554
Przykład użycia interfejsu Observer ...................................................y.................... 555
Klasy Timer i TimerTask ...................................................y.......................................... 557
Klasa Currency ...................................................y...................................................y....... 560
Klasa Formatter ...................................................y...................................................y...... 561
Konstruktory klasy Formatter ...................................................y............................. 561
Metody klasy Formatter ...................................................y...................................... 562
Podstawy formatowania ...................................................y...................................... 562
Formatowanie tekstów i znaków ...................................................y......................... 565
12
Java. Kompendium programisty
Formatowanie liczb ...................................................y............................................. 565
Formatowanie daty i godziny ...................................................y.............................. 567
Specyfikatory n i ...................................................y...................................... 567
Określanie minimalnej szerokości pola ...................................................y............... 569
Określanie precyzji ...................................................y.............................................. 570
Używanie znaczników formatów ...................................................y........................ 571
Wyrównywanie danych wyjściowych ...................................................y................. 572
Znaczniki spacji, plusa, zera i nawiasów ...................................................y............. 573
Znacznik przecinka ...................................................y............................................. 574
Znacznik # ...................................................y...................................................y........ 574
Opcja wielkich liter ...................................................y............................................. 574
Stosowanie indeksu argumentu ...................................................y........................... 575
Metoda printf() w Javie ...................................................y....................................... 576
Klasa Scanner ...................................................y...................................................y......... 577
Konstruktory klasy Scanner ...................................................y................................ 577
Podstawy skanowania ...................................................y......................................... 578
Kilka przykładów użycia klasy Scanner ...................................................y.............. 580
Ustawianie separatorów ...................................................y...................................... 585
Pozostałe elementy klasy Scanner ...................................................y....................... 586
Podpakiety pakietu java.util ...................................................y...................................... 587
java.util.concurrent, java.util.concurrent.atomic oraz java.util.concurrent.locks ... 588
java.util.jar ...................................................y...................................................y....... 588
java.util.logging ...................................................y.................................................. 588
java.util.prefs ...................................................y...................................................y.... 588
java.util.regex ...................................................y...................................................y... 588
java.util.zip ...................................................y...................................................y....... 588
Rozdział 19. Operacje wejścia-wyjścia: analiza pakietu java.io ........................... 589
Dostępne w Javie klasy i interfejsy obsługujące operacje wejścia-wyjścia .................. 590
Klasa File ...................................................y...................................................y............... 590
Katalogi ...................................................y...................................................y............ 593
Stosowanie interfejsu FilenameFilter ...................................................y.................. 594
Alternatywna metoda listFiles() ...................................................y.......................... 595
Tworzenie katalogów ...................................................y.......................................... 596
Interfejsy Closeable i Flushable ...................................................y................................ 596
Klasy strumienia ...................................................y...................................................y..... 597
Strumienie bajtów ...................................................y...................................................y.. 597
Klasa InputStream ...................................................y............................................... 598
Klasa OutputStream ...................................................y............................................ 598
Klasa FileInputStream ...................................................y......................................... 599
Klasa FileOutputStream ...................................................y...................................... 601
Klasa ByteArrayInputStream ...................................................y.............................. 602
Klasa ByteArrayOutputStream ...................................................y............................ 603
Filtrowane strumienie bajtów ...................................................y.............................. 605
Buforowane strumienie bajtów ...................................................y........................... 605
Klasa SequenceInputStream ...................................................y................................ 609
Klasa PrintStream ..................................................y................................................. 610
Klasy DataOutputStream i DataInputStream ..................................................y........ 613
Klasa RandomAccessFile ...................................................y.................................... 615
Strumienie znaków ...................................................y...................................................y. 616
Klasa Reader ...................................................y...................................................y.... 616
Klasa Writer ...................................................y...................................................y..... 616
Klasa FileReader ...................................................y................................................. 616
Klasa FileWriter ...................................................y.................................................. 618
Spis treści
13
Klasa CharArrayReader ...................................................y...................................... 619
Klasa CharArrayWriter ...................................................y....................................... 620
Klasa BufferedReader ...................................................y......................................... 621
Klasa BufferedWriter ...................................................y.......................................... 623
Klasa PushbackReader ...................................................y........................................ 623
Klasa PrintWriter ...................................................y................................................ 624
Stosowanie operacji wejścia-wyjścia na strumieniach ................................................. 626
Usprawnienie metody wc() przez zastosowanie klasy StreamTokenizer ............... 627
Serializacja ...................................................y...................................................y............. 629
Interfejs Serializable ...................................................y............................................ 630
Interfejs Externalizable ...................................................y....................................... 630
Interfejs ObjectOutput ...................................................y......................................... 631
Klasa ObjectOutputStream ...................................................y.................................. 631
Interfejs ObjectInput ....................
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ą :