Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00070 005404 20484112 na godz. na dobę w sumie
wyszukaj dokładnie | pobierz wtyczkę
Java. Kompendium programisty - książka
Java. Kompendium programisty - książka
Autor: Liczba stron: 1112
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-862-7 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook, audiobook).
Czytaj online.
Komentuj

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.

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ę:

Java. Kompendium programisty
Autor:
Sklep
Format
Cena
Helion.pl Helion.pl
książka
125,00 zł
Idź do sklepu »

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ą: