Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00266 015674 20462376 na godz. na dobę w sumie
wyszukaj dokładnie | pobierz wtyczkę
Java. Kompendium programisty. Wydanie X - książka
Java. Kompendium programisty. Wydanie X - książka
Autor: Liczba stron: 1152
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-4613-0 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> webmasterstwo >> jsp i javaservlet - programowanie
Porównaj ceny (książka, ebook, audiobook).
Czytaj online.
Komentuj

Niemal od chwili swojego powstania Java jest jednym z najważniejszych i najpopularniejszych języków programowania. Dzieje się tak dzięki konsekwentnemu rozwijaniu tego języka i poszukiwaniu coraz to nowszych technologii. Sprawia to, że Java jest pierwszym i najlepszym wyborem dla programistów zainteresowanych tworzeniem aplikacji internetowych. Oprócz tego nadaje się do wielu innych zastosowań. Łatwo się można przekonać, że większość współczesnego świata korzysta z kodu Javy. Dotyczy to nie tylko komputerów czy smartfonów, ale także ogromnej liczby różnych innych urządzeń.

Ta książka jest X wydaniem znakomitego podręcznika, w pełni zaktualizowanym o informacje dotyczące Java SE 9. W przystępny sposób wyjaśniono tu, jak pisać, kompilować, debugować i uruchamiać kod Javy. Znalazły się tu także informacje o kluczowych elementach biblioteki Java API, takich jak obsługa wejścia-wyjścia, Collections Framework, biblioteka strumieni oraz narzędzia do programowania współbieżnego. W praktyczny sposób przedstawiono bibliotekę Swing, JavaFX, technologię JavaBeans oraz serwletów. Książka zawiera także szczegółowy opis modułów i praktyczne wprowadzenie do JShell, narzędzia do interaktywnego programowania w Javie.

Najważniejsze zagadnienia ujęte w książce:

Java. Klasyka w programowaniu!

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

Darmowy fragment publikacji:

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

Gdzie kupić całą publikację:

Java. Kompendium programisty. Wydanie X
Autor:
Sklep
Format
Cena
Helion.pl Helion.pl
książka
179,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ą: