Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00417 007043 14246484 na godz. na dobę w sumie
Java. Kompendium programisty. Wydanie VIII - książka
Java. Kompendium programisty. Wydanie VIII - książka
Autor: Liczba stron: 1184
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-3767-6 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook (-20%), audiobook).

Podobnie jak wcześniejsze popularne języki programowania komputerów, Java jest mieszanką najlepszych elementów swoich poprzedników. Jej dodatkową zaletą jest innowacyjna koncepcja samego języka, wynikająca z unikatowej misji. Obecnie Java jest bardzo chętnie wykorzystywana we wszelkich projektach informatycznych. Silne typowanie, jasno określona, przejrzysta składnia oraz ogromna liczba bibliotek rozwiązujących najbardziej wymyślne problemy zyskuje jej wielu zwolenników.

Książka, którą trzymasz w ręku, jest unikalną pozycją, gdyż jako jedna z pierwszych omawia nowości z ostatniego wydania języka Java, oznaczonego numerem 7. Znajdziesz w niej informacje na temat nowego API do obsługi operacji wejścia-wyjścia, wykorzystania łańcuchów znaków w wyrażeniach switch oraz wychwytywania wielu wyjątków w ramach jednego bloku catch. Poza nowościami autor omawia konstrukcje obecne w języku od lat. Książka ta jest idealną propozycją dla każdego programisty Javy, który może po nią sięgać wybiórczo, jeżeli będzie miał wątpliwości co do sposobu rozwiązania konkretnego problemu. Natomiast dla osób, które chcą poznać język Java i wkroczyć w świat zaawansowanych technologii, będzie ona pasjonującym przewodnikiem.

W trakcie lektury:

Kompletne źródło informacji na temat języka Java!

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: Java The Complete Reference, 8th Edition Tłumaczenie: Mikołaj Szczepaniak ISBN: 978-83-246-3767-6 © Helion 2012 All rights reserved Original edition copyright © 2011 by McGraw-Hill Companies, Inc. All rights reserved. Polish edition copyright © 2012 by HELION SA All rights reserved. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/javkp8.zip Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/javkp8 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treĈci O autorze ................................................................................................. 23 O redaktorze merytorycznym ......................................................................................................23 Przedmowa .............................................................................................. 25 Jözyk Java ............................................................................ 29 CzöĈè I Rozdziaä 1. Historia i ewolucja jözyka Java ................................................................. 31 Rodowód Javy .............................................................................................................................31 Narodziny nowoczesnego jĊzyka — C ..................................................................................32 JĊzyk C++ — nastĊpny krok .................................................................................................33 Podwaliny jĊzyka Java ..........................................................................................................34 Powstanie jĊzyka Java .................................................................................................................34 Powiązanie z jĊzykiem C# ....................................................................................................36 Jak jĊzyk Java zmieniá internet ....................................................................................................36 Aplety Javy ...........................................................................................................................37 BezpieczeĔstwo .....................................................................................................................37 PrzenoĞnoĞü ...........................................................................................................................38 Magia jĊzyka Java — kod bajtowy ..............................................................................................38 Serwlety — Java po stronie serwera ............................................................................................39 Hasáa jĊzyka Java ........................................................................................................................40 Prostota ..................................................................................................................................40 ObiektowoĞü ..........................................................................................................................40 NiezawodnoĞü .......................................................................................................................41 WielowątkowoĞü ...................................................................................................................41 NeutralnoĞü architektury .......................................................................................................42 InterpretowalnoĞü i wysoka wydajnoĞü .................................................................................42 Rozproszenie .........................................................................................................................42 Dynamika ..............................................................................................................................42 Ewolucja Javy ..............................................................................................................................42 Java SE 7 ...............................................................................................................................44 Kultura innowacji ........................................................................................................................46 Rozdziaä 2. Podstawy jözyka Java ............................................................................... 47 Programowanie obiektowe ..........................................................................................................47 Dwa paradygmaty .................................................................................................................47 Abstrakcja .............................................................................................................................48 Trzy zasady programowania obiektowego ............................................................................48 4 Java. Kompendium programisty Pierwszy przykáadowy program ..................................................................................................53 Wpisanie kodu programu ......................................................................................................54 Kompilacja programów .........................................................................................................54 BliĪsze spojrzenie na pierwszy przykáadowy program ..........................................................55 Drugi prosty program ..................................................................................................................57 Dwa wyraĪenia sterujące .............................................................................................................59 WyraĪenie if ..........................................................................................................................59 PĊtla for .................................................................................................................................60 Bloki kodu ...................................................................................................................................61 Kwestie skáadniowe .....................................................................................................................63 Znaki biaáe .............................................................................................................................63 Identyfikatory ........................................................................................................................63 Staáe .......................................................................................................................................63 Komentarze ...........................................................................................................................64 Separatory .............................................................................................................................64 Sáowa kluczowe jĊzyka Java .................................................................................................64 Biblioteki klas Javy .....................................................................................................................65 Rozdziaä 3. Typy danych, zmienne i tablice ................................................................. 67 Java to jĊzyk ze Ğcisáą kontrolą typów .........................................................................................67 Typy proste ..................................................................................................................................67 Typy caákowitoliczbowe ..............................................................................................................68 Typ byte ................................................................................................................................69 Typ short ...............................................................................................................................69 Typ int ...................................................................................................................................69 Typ long ................................................................................................................................69 Typy zmiennoprzecinkowe ..........................................................................................................70 Typ float ................................................................................................................................71 Typ double ............................................................................................................................71 Typ znakowy ...............................................................................................................................71 Typ logiczny ................................................................................................................................73 BliĪsze spojrzenie na staáe ...........................................................................................................74 Staáe caákowitoliczbowe ........................................................................................................74 Staáe zmiennoprzecinkowe ....................................................................................................75 Staáe logiczne ........................................................................................................................76 Staáe znakowe ........................................................................................................................76 Staáe áaĔcuchowe ...................................................................................................................77 Zmienne .......................................................................................................................................77 Deklaracja zmiennej ..............................................................................................................78 Inicjalizacja dynamiczna .......................................................................................................78 ZasiĊg i czas Īycia zmiennych ..............................................................................................79 Konwersja typów i rzutowanie ....................................................................................................81 Automatyczna konwersja typów ...........................................................................................81 Rzutowanie niezgodnych typów ............................................................................................82 Automatyczne rozszerzanie typów w wyraĪeniach .....................................................................83 Zasady rozszerzania typu ......................................................................................................84 Tablice .........................................................................................................................................85 Tablice jednowymiarowe ......................................................................................................85 Tablice wielowymiarowe ......................................................................................................87 Alternatywna skáadnia deklaracji tablicy ...............................................................................91 Kilka sáów o áaĔcuchach ..............................................................................................................92 Uwaga dla programistów jĊzyka C lub C++ na temat wskaĨników .............................................92 Spis treĈci 5 Rozdziaä 4. Operatory ................................................................................................. 93 Operatory arytmetyczne ..............................................................................................................93 Podstawowe operatory arytmetyczne ....................................................................................94 Operator reszty z dzielenia ....................................................................................................95 Operatory arytmetyczne z przypisaniem ...............................................................................95 Inkrementacja i dekrementacja ..............................................................................................96 Operatory bitowe .........................................................................................................................98 Logiczne operatory bitowe ....................................................................................................99 PrzesuniĊcie w lewo ............................................................................................................101 PrzesuniĊcie w prawo ..........................................................................................................103 PrzesuniĊcie w prawo bez znaku .........................................................................................104 Operatory bitowe z przypisaniem ........................................................................................105 Operatory relacji ........................................................................................................................106 Operatory logiczne ....................................................................................................................107 Operatory logiczne ze skracaniem .......................................................................................109 Operator przypisania ..................................................................................................................109 Operator ? ..................................................................................................................................110 KolejnoĞü wykonywania operatorów .........................................................................................111 Stosowanie nawiasów okrągáych ...............................................................................................112 Rozdziaä 5. WyraĔenia sterujñce ............................................................................... 113 Instrukcje wyboru ......................................................................................................................113 Konstrukcja if ......................................................................................................................113 Konstrukcja switch ..............................................................................................................116 Instrukcje iteracyjne ..................................................................................................................121 PĊtla while ...........................................................................................................................121 PĊtla do-while ......................................................................................................................122 PĊtla for ...............................................................................................................................125 Wersja for-each pĊtli for ......................................................................................................128 PĊtle zagnieĪdĪone ..............................................................................................................133 Instrukcje skoku .........................................................................................................................134 Instrukcja break ...................................................................................................................134 Instrukcja continue ..............................................................................................................138 Instrukcja return ..................................................................................................................139 Rozdziaä 6. Wprowadzenie do klas ............................................................................ 141 Klasy ..........................................................................................................................................141 Ogólna postaü klasy ............................................................................................................141 Prosta klasa ..........................................................................................................................142 Deklarowanie obiektów .............................................................................................................145 BliĪsze spojrzenie na operator new .....................................................................................146 Przypisywanie zmiennych referencyjnych do obiektów ............................................................147 Wprowadzenie do metod ...........................................................................................................148 Dodanie metody do klasy Box ............................................................................................148 Zwracanie wartoĞci .............................................................................................................150 Dodanie metody przyjmującej parametry ............................................................................151 Konstruktor ................................................................................................................................153 Konstruktor sparametryzowany ...........................................................................................155 Sáowo kluczowe this ..................................................................................................................156 Ukrywanie zmiennych skáadowych .....................................................................................157 Mechanizm odzyskiwania pamiĊci ............................................................................................157 Metoda finalize() .......................................................................................................................158 Klasa stosu .................................................................................................................................158 6 Java. Kompendium programisty Rozdziaä 7. Dokäadniejsze omówienie metod i klas .................................................... 161 PrzeciąĪanie metod ....................................................................................................................161 PrzeciąĪanie konstruktorów .................................................................................................164 Obiekty jako parametry .............................................................................................................166 Dokáadniejsze omówienie przekazywania argumentów ............................................................168 Zwracanie obiektów ..................................................................................................................170 Rekurencja .................................................................................................................................171 Wprowadzenie do kontroli dostĊpu ...........................................................................................173 Skáadowe statyczne ...................................................................................................................176 Sáowo kluczowe final ................................................................................................................178 Powtórka z tablic .......................................................................................................................179 Klasy zagnieĪdĪone i klasy wewnĊtrzne ....................................................................................181 Omówienie klasy String ............................................................................................................183 Wykorzystanie argumentów wiersza poleceĔ ............................................................................186 Zmienna liczba argumentów ......................................................................................................187 PrzeciąĪanie metod o zmiennej liczbie argumentów ...........................................................190 Zmienna liczba argumentów i niejednoznacznoĞci .............................................................191 Rozdziaä 8. Dziedziczenie ......................................................................................... 193 Podstawy dziedziczenia .............................................................................................................193 DostĊp do skáadowych a dziedziczenie ...............................................................................195 Bardziej praktyczny przykáad ..............................................................................................196 Zmienna klasy bazowej moĪe zawieraü referencjĊ do obiektu podklasy .............................198 Sáowo kluczowe super ...............................................................................................................199 Wykorzystanie sáowa kluczowego super do wywoáania konstruktora klasy bazowej .........199 Drugie zastosowanie sáowa kluczowego super ....................................................................202 Tworzenie hierarchii wielopoziomowej ....................................................................................203 Kiedy dochodzi do wywoáania konstruktorów? .........................................................................206 Przesáanianie metod ...................................................................................................................207 Dynamiczne przydzielanie metod ..............................................................................................209 Dlaczego warto przesáaniaü metody? ..................................................................................211 Zastosowanie przesáaniania metod ......................................................................................211 Klasy abstrakcyjne .....................................................................................................................213 Sáowo kluczowe final i dziedziczenie ........................................................................................216 Sáowo kluczowe final zapobiega przesáanianiu ...................................................................216 Sáowo kluczowe final zapobiega dziedziczeniu ..................................................................216 Klasa Object ..............................................................................................................................217 Rozdziaä 9. Pakiety i interfejsy ................................................................................. 219 Pakiety .......................................................................................................................................219 Definiowanie pakietu ..........................................................................................................220 Znajdowanie pakietów i ĞcieĪka CLASSPATH ..................................................................220 Prosty przykáad pakietu .......................................................................................................221 Ochrona dostĊpu ........................................................................................................................222 Przykáad dostĊpu .................................................................................................................223 Import pakietów .........................................................................................................................226 Interfejsy ....................................................................................................................................228 Definiowanie interfejsu .......................................................................................................228 Implementacja interfejsu .....................................................................................................229 Interfejsy zagnieĪdĪone .......................................................................................................232 Stosowanie interfejsów ........................................................................................................233 Zmienne w interfejsach .......................................................................................................236 Interfejsy moĪna rozszerzaü ................................................................................................238 Spis treĈci 7 Rozdziaä 10. Obsäuga wyjñtków .................................................................................. 239 Podstawy obsáugi wyjątków ......................................................................................................239 Typy wyjątków ..........................................................................................................................240 Nieprzechwycone wyjątki .........................................................................................................241 Stosowanie konstrukcji try i catch .............................................................................................242 WyĞwietlenie opisu wyjątku ................................................................................................243 Wiele klauzul catch ...................................................................................................................244 ZagnieĪdĪone konstrukcje try ....................................................................................................245 Instrukcja throw .........................................................................................................................247 Klauzula throws .........................................................................................................................249 Sáowo kluczowe finally .............................................................................................................250 Wyjątki wbudowane w jĊzyk Java .............................................................................................251 Tworzenie wáasnej podklasy wyjątków .....................................................................................252 àaĔcuch wyjątków .....................................................................................................................255 Trzy nowe cechy wyjątków w wersji JDK 7 .............................................................................256 Wykorzystanie wyjątków ..........................................................................................................258 Rozdziaä 11. Programowanie wielowñtkowe ................................................................ 259 Model wątków jĊzyka Java ........................................................................................................260 Priorytety wątków ...............................................................................................................261 Synchronizacja ....................................................................................................................262 Przekazywanie komunikatów ..............................................................................................262 Klasa Thread i interfejs Runnable .......................................................................................262 Wątek gáówny ............................................................................................................................263 Tworzenie wątku .......................................................................................................................265 Implementacja interfejsu Runnable .....................................................................................265 Rozszerzanie klasy Thread ..................................................................................................267 Wybór odpowiedniego podejĞcia ........................................................................................268 Tworzenie wielu wątków ...........................................................................................................269 Stosowanie metod isAlive() i join() ...........................................................................................270 Priorytety wątków .....................................................................................................................272 Synchronizacja ..........................................................................................................................273 Synchronizacja metod .........................................................................................................274 Konstrukcja synchronized ...................................................................................................276 Komunikacja miĊdzywątkowa ...................................................................................................277 Zakleszczenie ......................................................................................................................282 Zawieszanie, wznawianie i zatrzymywanie wątków .................................................................284 Zawieszanie, wznawianie i zatrzymywanie wątków do wersji Java 1.1 ..............................284 Nowoczesny sposób zawieszania, wznawiania i zatrzymywania wątków ...........................286 Uzyskiwanie stanu wątku ..........................................................................................................289 Korzystanie z wielowątkowoĞci ................................................................................................290 Rozdziaä 12. Wyliczenia, automatyczne opakowywanie typów prostych i adnotacje (metadane) ............................................................................................ 291 Typy wyliczeniowe ...................................................................................................................291 Podstawy wyliczeĔ ..............................................................................................................292 Metody values() i valueOf() ................................................................................................294 Wyliczenia Javy jako typy klasowe .....................................................................................295 Wyliczenia dziedziczą po klasie Enum ...............................................................................297 Inny przykáad wyliczenia ....................................................................................................299 Opakowania typów ....................................................................................................................300 Klasa Character ...................................................................................................................301 Klasa Boolean .....................................................................................................................301 Opakowania typów numerycznych .....................................................................................301 8 Java. Kompendium programisty Automatyczne opakowywanie typów prostych .........................................................................303 Automatyczne opakowywanie i metody ..............................................................................304 Automatyczne opakowywanie i rozpakowywanie w wyraĪeniach ......................................304 Automatyczne opakowywanie typów znakowych i logicznych ..........................................306 Automatyczne opakowywanie pomaga zapobiegaü báĊdom ................................................307 Sáowo ostrzeĪenia ................................................................................................................308 Adnotacje (metadane) ................................................................................................................308 Podstawy tworzenia adnotacji .............................................................................................308 OkreĞlanie strategii zachowywania adnotacji ......................................................................309 Odczytywanie adnotacji w trakcie dziaáania programu za pomocą refleksji .......................310 Interfejs AnnotatedElement .................................................................................................315 WartoĞci domyĞlne ..............................................................................................................315 Adnotacje znacznikowe .......................................................................................................317 Adnotacje jednoelementowe ...............................................................................................318 Wbudowane adnotacje ........................................................................................................319 Ograniczenia .......................................................................................................................321 Rozdziaä 13. WejĈcie-wyjĈcie, aplety i inne tematy ...................................................... 323 Podstawowa obsáuga wejĞcia i wyjĞcia ......................................................................................323 Strumienie ...........................................................................................................................324 Strumienie znakowe i bajtowe .............................................................................................324 Predefiniowane strumienie ..................................................................................................326 Odczyt danych z konsoli ............................................................................................................327 Odczyt znaków ....................................................................................................................327 Odczyt áaĔcuchów ...............................................................................................................328 WyĞwietlanie informacji na konsoli ..........................................................................................330 Klasa PrintWriter .......................................................................................................................331 Odczyt i zapis plików ................................................................................................................332 Automatyczne zamykanie pliku .................................................................................................338 Podstawy apletów ......................................................................................................................341 Modyfikatory transient i volatile ...............................................................................................344 Operator instanceof ...................................................................................................................345 Modyfikator strictfp ...................................................................................................................347 Metody napisane w kodzie rdzennym ........................................................................................347 Problemy z metodami rdzennymi ..............................................................................................351 Stosowanie asercji .....................................................................................................................351 Opcje wáączania i wyáączania asercji ..................................................................................354 Import statyczny ........................................................................................................................354 Wywoáywanie przeciąĪonych konstruktorów za pomocą this() .................................................357 Rozdziaä 14. Typy sparametryzowane .......................................................................... 361 Czym są typy sparametryzowane? .............................................................................................362 Prosty przykáad zastosowania typów sparametryzowanych ......................................................362 Typy sparametryzowane dziaáają tylko dla obiektów ..........................................................366 Typy sparametryzowane róĪnią siĊ, jeĞli mają inny argument typu ....................................366 W jaki sposób typy sparametryzowane zwiĊkszają bezpieczeĔstwo? .................................366 Klasa sparametryzowana z dwoma parametrami typu ...............................................................369 Ogólna postaü klasy sparametryzowanej ...................................................................................370 Typy ograniczone ......................................................................................................................370 Zastosowanie argumentów wieloznacznych ..............................................................................373 Ograniczony argument wieloznaczny .................................................................................375 Tworzenie metody sparametryzowanej .....................................................................................380 Konstruktory sparametryzowane .........................................................................................382 Interfejsy sparametryzowane .....................................................................................................383 Typy surowe i starszy kod .........................................................................................................385 Spis treĈci 9 Hierarchia klas sparametryzowanych ........................................................................................388 Zastosowanie sparametryzowanej klasy bazowej ................................................................388 Podklasa sparametryzowana ................................................................................................390 Porównywanie typów w hierarchii klas sparametryzowanych w czasie wykonywania .......391 Rzutowanie ..........................................................................................................................393 Przykrywanie metod w klasach sparametryzowanych .........................................................394 Wnioskowanie typów a typy sparametryzowane .......................................................................395 Znoszenie ..................................................................................................................................397 Metody mostu ......................................................................................................................398 BáĊdy niejednoznacznoĞci .........................................................................................................400 Pewne ograniczenia typów sparametryzowanych ......................................................................401 Nie moĪna tworzyü egzemplarza parametru typu ................................................................401 Ograniczenia dla skáadowych statycznych ..........................................................................402 Ograniczenia tablic typów sparametryzowanych ................................................................402 Ograniczenia wyjątków typów sparametryzowanych ..........................................................404 CzöĈè II Biblioteka jözyka Java ........................................................ 405 Rozdziaä 15. Obsäuga äaþcuchów ................................................................................ 407 Konstruktory klasy String ..........................................................................................................408 DáugoĞü áaĔcucha .......................................................................................................................410 Specjalne operacje na áaĔcuchach ..............................................................................................410 Literaáy tekstowe .................................................................................................................410 Konkatenacja áaĔcuchów .....................................................................................................411 Konkatenacja áaĔcuchów z innymi typami danych .............................................................411 Konwersja áaĔcuchów i metoda toString() ..........................................................................412 WyodrĊbnianie znaków .............................................................................................................413 Metoda charAt() ..................................................................................................................413 Metoda getChars() ...............................................................................................................414 Metoda getBytes() ...............................................................................................................414 Metoda toCharArray() .........................................................................................................415 Porównywanie áaĔcuchów .........................................................................................................415 Metody equals() i equalsIgnoreCase() .................................................................................415 Metoda regionMatches() .....................................................................................................416 Metody startsWith() i endsWith() ........................................................................................416 Metoda equals() kontra operator == ....................................................................................417 Metoda compareTo() ...........................................................................................................417 Przeszukiwanie áaĔcuchów ........................................................................................................419 Modyfikowanie áaĔcucha ..........................................................................................................420 Metoda substring() ..............................................................................................................421 Metoda concat() ..................................................................................................................422 Metoda replace() .................................................................................................................422 Metoda trim() ......................................................................................................................422 Konwersja danych za pomocą metody valueOf() ......................................................................423 Zmiana wielkoĞci liter w áaĔcuchu ............................................................................................424 Dodatkowe metody klasy String ................................................................................................425 Klasa StringBuffer .....................................................................................................................425 Konstruktory klasy StringBuffer .........................................................................................425 Metody length() i capacity() ................................................................................................427 Metoda ensureCapacity() ....................................................................................................427 Metoda setLength() .............................................................................................................427 Metody charAt() i setCharAt() ............................................................................................428 Metoda getChars() ...............................................................................................................428 Metoda append() .................................................................................................................429 10 Java. Kompendium programisty Metoda insert() ....................................................................................................................429 Metoda reverse() .................................................................................................................430 Metody delete() i deleteCharAt() ........................................................................................430 Metoda replace() .................................................................................................................431 Metoda substring() ..............................................................................................................431 Dodatkowe metody klasy StringBuffer ...............................................................................432 Klasa StringBuilder ...................................................................................................................433 Rozdziaä 16. Pakiet java.lang ..................................................................................... 435 Opakowania typów prostych .....................................................................................................436 Klasa Number ......................................................................................................................436 Klasy Double i Float ...........................................................................................................436 Klasy Byte, Short, Integer i Long ........................................................................................440 Klasa Character ...................................................................................................................448 Dodatki wprowadzone w celu obsáugi punktów kodowych Unicode ..................................450 Klasa Boolean .....................................................................................................................451 Klasa Void .................................................................................................................................451 Klasa Process .............................................................................................................................452 Klasa Runtime ...........................................................................................................................454 Zarządzanie pamiĊcią ..........................................................................................................454 Wykonywanie innych programów .......................................................................................456 Klasa ProcessBuilder .................................................................................................................457 Klasa System .............................................................................................................................459 Wykorzystanie metody currentTimeMillis() do obliczania czasu wykonywania programu .......461 UĪycie metody arraycopy() .................................................................................................462 WáaĞciwoĞci Ğrodowiska .....................................................................................................462 Klasa Object ..............................................................................................................................463 Wykorzystanie metody clone() i interfejsu Cloneable ...............................................................464 Klasa Class ................................................................................................................................466 Klasa ClassLoader .....................................................................................................................468 Klasa Math ................................................................................................................................469 Funkcje trygonometryczne ..................................................................................................469 Funkcje wykáadnicze ...........................................................................................................469 Funkcje zaokrągleĔ .............................................................................................................470 RóĪnorodne metody klasy Math ..........................................................................................470 Klasa StrictMath ........................................................................................................................471 Klasa Compiler ..........................................................................................................................472 Klasy Thread i ThreadGroup oraz interfejs Runnable ...............................................................472 Interfejs Runnable ...............................................................................................................473 Klasa Thread .......................................................................................................................473 Klasa ThreadGroup .............................................................................................................473 Klasy ThreadLocal i InheritableThreadLocal ............................................................................479 Klasa Package ............................................................................................................................479 Klasa RuntimePermission ..........................................................................................................480 Klasa Throwable ........................................................................................................................480 Klasa SecurityManager ..............................................................................................................481 Klasa StackTraceElement ..........................................................................................................481 Klasa Enum ...............................................................................................................................482 Klasa ClassValue .......................................................................................................................482 Interfejs CharSequence ..............................................................................................................483 Interfejs Comparable .................................................................................................................483 Interfejs Appendable ..................................................................................................................483 Interfejs Iterable .........................................................................................................................484 Interfejs Readable ......................................................................................................................484 Interfejs AutoCloseable .............................................................................................................484 Spis treĈci 11 Interfejs Thread.UncaughtExceptionHandler ............................................................................485 Podpakiety pakietu java.lang .....................................................................................................485 Podpakiet java.lang.annotation ............................................................................................486 Podpakiet java.lang.instrument ...........................................................................................486 Podpakiet java.lang.invoke ..................................................................................................486 Podpakiet java.lang.management ........................................................................................486 Podpakiet java.lang.ref ........................................................................................................486 Podpakiet java.lang.reflect ..................................................................................................486 Rozdziaä 17. Pakiet java.util, czöĈè 1. — kolekcje ...................................................... 487 Wprowadzenie do kolekcji ........................................................................................................488 Zmiany w kolekcjach wprowadzone w JDK 5 ..........................................................................489 Typy sparametryzowane w znaczący sposób zmieniają kolekcje ........................................489 Automatyczne opakowywanie uáatwia korzystanie z typów prostych .................................490 PĊtla for typu for-each .........................................................................................................490 Interfejsy kolekcji ......................................................................................................................490 Interfejs Collection ..............................................................................................................491 Interfejs List ........................................................................................................................493 Interfejs Set .........................................................................................................................494 Interfejs SortedSet ...............................................................................................................495 Interfejs NavigableSet .........................................................................................................495 Interfejs Queue ....................................................................................................................496 Interfejs Deque ....................................................................................................................496 Klasy kolekcji ............................................................................................................................499 Klasa ArrayList ...................................................................................................................500 Klasa LinkedList .................................................................................................................504 Klasa HashSet .....................................................................................................................505 Klasa LinkedHashSet ..........................................................................................................506 Klasa TreeSet ......................................................................................................................507 Klasa PriorityQueue ............................................................................................................508 Klasa ArrayDeque ...............................................................................................................509 Klasa EnumSet ....................................................................................................................510 DostĊp do kolekcji za pomocą iteratora .....................................................................................510 Korzystanie z iteratora Iterator ............................................................................................512 PĊtla typu for-each jako alternatywa dla iteratora ...............................................................514 Przechowywanie w kolekcjach wáasnych klas ...........................................................................515 Interfejs RandomAccess ............................................................................................................516 Korzystanie z map .....................................................................................................................516 Interfejsy map ......................................................................................................................517 Klasy map ...........................................................................................................................519 Komparatory ..............................................................................................................................526 Wykorzystanie komparatora ................................................................................................527 Algorytmy kolekcji ....................................................................................................................529 Klasa Arrays ..............................................................................................................................534 Dlaczego kolekcje są sparametryzowane? .................................................................................539 Starsze klasy i interfejsy ............................................................................................................541 Interfejs Enumeration ..........................................................................................................542 Klasa Vector ........................................................................................................................542 Klasa Stack ..........................................................................................................................546 Klasa Dictionary ..................................................................................................................548 Klasa Hashtable ...................................................................................................................549 Klasa Properties ..................................................................................................................552 Wykorzystanie metod store() i load() ..................................................................................555 Ostatnie uwagi na temat kolekcji ...............................................................................................557 12 Java. Kompendium programisty Rozdziaä 18. Pakiet java.util, czöĈè 2. — pozostaäe klasy uĔytkowe ............................ 559 Klasa StringTokenizer ...............................................................................................................559 Klasa BitSet ...............................................................................................................................561 Klasa Date .................................................................................................................................564 Klasa Calendar ..........................................................................................................................566 Klasa GregorianCalendar ..........................................................................................................569 Klasa TimeZone ........................................................................................................................570 Klasa SimpleTimeZone .............................................................................................................571 Klasa Locale ..............................................................................................................................572 Klasa Random ...........................................................................................................................574 Klasa Observable .......................................................................................................................576 Interfejs Observer ................................................................................................................577 Przykáad uĪycia interfejsu Observer ....................................................................................577 Klasy Timer i TimerTask ..........................................................................................................580 Klasa Currency ..........................................................................................................................582 Klasa Formatter .........................................................................................................................583 Konstruktory klasy Formatter ..............................................................................................584 Metody klasy Formatter ......................................................................................................585 Podstawy formatowania ......................................................................................................585 Formatowanie áaĔcuchów i znaków ....................................................................................588 Formatowanie liczb .............................................................................................................588 Formatowanie daty i godziny ..............................................................................................589 Specyfikatory n i ......................................................................................................591 OkreĞlanie minimalnej szerokoĞci pola ...............................................................................591 OkreĞlanie precyzji ..............................................................................................................593 UĪywanie znaczników (flag) formatów ...............................................................................594 Wyrównywanie danych wyjĞciowych .................................................................................594 Znaczniki spacji, plusa, zera i nawiasów .............................................................................595 Znacznik przecinka .............................................................................................................596 Znacznik # ...........................................................................................................................596 Opcja wielkich liter ...................................................................................
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Java. Kompendium programisty. Wydanie VIII
Autor:

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