Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00359 007238 20519856 na godz. na dobę w sumie
Java. Podstawy. Wydanie XI - książka
Java. Podstawy. Wydanie XI - książka
Autor: Liczba stron: 768
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-5778-5 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook (-30%), audiobook).

Świat usłyszał o Javie pod koniec 1995 roku. Wkrótce stała się niezwykle popularną i cenioną technologią. Dziś jest dojrzałym, rozbudowanym, elastycznym, a przy tym niezwykle starannie zaprojektowanym językiem programowania, który może służyć do pisania dużych systemów, małych programów, aplikacji mobilnych i aplikacji WWW. Charakteryzuje się też wysublimowanymi zabezpieczeniami, które w niego wbudowano. Każdy, kto chce pisać dobry i wydajny kod, powinien dobrze poznać zarówno podstawowe, jak i zaawansowane cechy Javy.

Ta książka jest kolejnym, zaktualizowanym i uzupełnionym wydaniem kultowego podręcznika dla profesjonalnych programistów Javy - to pierwszy tom, w którym omówiono podstawy języka oraz najważniejsze zagadnienia związane z programowaniem interfejsu użytkownika. W tym wydaniu opisano pakiet JDK Java Standard Edition (SE) w wersji 9, 10 i 11. Teorii towarzyszą liczne przykłady kodu, obrazujące zasady działania niemal każdej przedstawionej tu funkcji czy biblioteki. Przykładowe programy są proste, aby ułatwić naukę najważniejszych zagadnień.

W tej książce między innymi:

Java - oto język mistrzów programowania!

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

Darmowy fragment publikacji:

Tytuł oryginalny: Core Java Volume I - Fundamentals (11th Edition) Tłumaczenie: Łukasz Piwko ISBN: 978-83-283-5778-5 Authorized translation from the English language edition, entitled CORE JAVA VOLUME I – FUNDAMENTALS, 1, 11th Edition by HORSTMANN, CAY S., published by Pearson Education, Inc, publishing as Prentice Hall. Copyright © 2019 Pearson Education Inc. Portions copyright © 1996-2013 Oracle and/or its affiliates. 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 Pearson Education Inc. Polish language edition published by HELION S.A. Copyright © 2019. Microsoft® Windows®, and Microsoft Office® are registered trademarks of the Microsoft Corporation in the U.S.A. and other countries. This book is not sponsored or endorsed by or affiliated with the Microsoft. 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/javp11 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/javp11.zip Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treści Wstęp ........................................................................................................................................................13 Do Czytelnika ............................................................................................................... 13 O książce .................................................................................................................... 15 Konwencje typograficzne ............................................................................................... 17 Przykłady kodu ............................................................................................................. 17 Podziękowania .........................................................................................................................................19 Rozdział 1. Wprowadzenie do Javy .........................................................................................................21 1.1. Java jako platforma programistyczna ....................................................................... 21 1.2. Słowa klucze białej księgi Javy ............................................................................... 22 1.2.1. Prostota ....................................................................................................... 23 1.2.2. Obiektowość ................................................................................................. 23 1.2.3. Sieciowość ................................................................................................... 24 1.2.4. Niezawodność .............................................................................................. 24 1.2.5. Bezpieczeństwo ............................................................................................ 24 1.2.6. Niezależność od architektury .......................................................................... 25 1.2.7. Przenośność ................................................................................................. 26 1.2.8. Interpretacja ................................................................................................. 26 1.2.9. Wysoka wydajność ........................................................................................ 27 1.2.10. Wielowątkowość ......................................................................................... 27 1.2.11. Dynamiczność ............................................................................................ 27 1.3. Aplety Javy i internet .............................................................................................. 28 1.4. Krótka historia Javy ............................................................................................... 29 1.5. Główne nieporozumienia dotyczące Javy .................................................................. 32 Rozdział 2. Środowisko programistyczne Javy ...................................................................................35 2.1. Instalacja oprogramowania Java Development Kit .................................................... 35 2.1.1. Pobieranie pakietu JDK ................................................................................. 36 2.1.2. Instalacja pakietu JDK ................................................................................... 37 2.1.3. Instalacja plików źródłowych i dokumentacji .................................................... 39 2.2. Używanie narzędzi wiersza poleceń ......................................................................... 40 2.3. Praca w zintegrowanym środowisku programistycznym ............................................. 45 2.4. JShell ................................................................................................................... 48 Poleć książkęKup książkę 4 Java. Podstawy Rozdział 3. Podstawowe elementy języka Java .....................................................................................51 3.1. Prosty program w Javie .......................................................................................... 52 3.2. Komentarze .......................................................................................................... 55 3.3. Typy danych .......................................................................................................... 56 3.3.1. Typy całkowite .............................................................................................. 56 3.3.2. Typy zmiennoprzecinkowe .............................................................................. 57 3.3.3. Typ char ....................................................................................................... 58 3.3.4. Unicode i typ char ......................................................................................... 60 3.3.5. Typ boolean .................................................................................................. 61 3.4. Zmienne i stałe ..................................................................................................... 61 3.4.1. Deklarowanie zmiennych ............................................................................... 61 3.4.2. Inicjalizacja zmiennych .................................................................................. 62 3.4.3. Stałe ............................................................................................................ 63 3.4.4. Typ wyliczeniowy ........................................................................................... 64 3.5. Operatory ............................................................................................................. 65 3.5.1. Operatory arytmetyczne ................................................................................. 65 3.5.2. Funkcje i stałe matematyczne ........................................................................ 66 3.5.3. Konwersja typów numerycznych ...................................................................... 68 3.5.4. Rzutowanie ................................................................................................... 68 3.5.5. Łączenie przypisania z innymi operatorami ...................................................... 69 3.5.6. Operatory inkrementacji i dekrementacji ......................................................... 70 3.5.7. Operatory relacyjne i logiczne ......................................................................... 70 3.5.8. Operatory bitowe ........................................................................................... 71 3.5.9. Nawiasy i priorytety operatorów ...................................................................... 72 3.6. Łańcuchy .............................................................................................................. 73 3.6.1. Podłańcuchy ................................................................................................. 73 3.6.2. Konkatenacja ............................................................................................... 74 3.6.3. Łańcuchów nie można modyfikować ................................................................ 74 3.6.4. Porównywanie łańcuchów ............................................................................... 76 3.6.5. Łańcuchy puste i łańcuchy null ....................................................................... 77 3.6.6. Współrzędne kodowe znaków i jednostki kodowe ............................................. 77 3.6.7. API String ..................................................................................................... 78 3.6.8. Dokumentacja API w internecie ...................................................................... 81 3.6.9. Składanie łańcuchów ..................................................................................... 84 3.7. Wejście i wyjście ................................................................................................... 85 3.7.1. Odbieranie danych wejściowych ...................................................................... 85 3.7.2. Formatowanie danych wyjściowych ................................................................. 88 3.7.3. Zapis i odczyt plików ..................................................................................... 92 3.8. Sterowanie wykonywaniem programu ...................................................................... 94 3.8.1. Zasięg blokowy ............................................................................................. 94 3.8.2. Instrukcje warunkowe .................................................................................... 95 3.8.3. Pętle ............................................................................................................ 98 3.8.4. Pętle o określonej liczbie powtórzeń ............................................................. 101 3.8.5. Wybór wielokierunkowy — instrukcja switch .................................................. 105 3.8.6. Instrukcje przerywające przepływ sterowania ................................................. 107 3.9. Wielkie liczby ...................................................................................................... 110 3.10. Tablice ............................................................................................................. 112 3.10.1. Deklarowanie tablic ................................................................................... 112 3.10.2. Dostęp do elementów tablicy ..................................................................... 114 3.10.3. Pętla typu for each .................................................................................... 114 3.10.4. Kopiowanie tablicy .................................................................................... 115 Poleć książkęKup książkę Spis treści 5 3.10.5. Parametry wiersza poleceń ........................................................................ 116 3.10.6. Sortowanie tablicy ..................................................................................... 117 3.10.7. Tablice wielowymiarowe ............................................................................. 120 3.10.8. Tablice postrzępione ................................................................................. 122 Rozdział 4. Obiekty i klasy .....................................................................................................................127 4.1. Wstęp do programowania obiektowego ................................................................. 128 4.1.1. Klasy ......................................................................................................... 129 4.1.2. Obiekty ...................................................................................................... 129 4.1.3. Identyfikacja klas ........................................................................................ 130 4.1.4. Relacje między klasami ............................................................................... 131 4.2. Używanie klas predefiniowanych ........................................................................... 132 4.2.1. Obiekty i zmienne obiektów .......................................................................... 133 4.2.2. Klasa LocalDate ......................................................................................... 135 4.2.3. Metody udostępniające i zmieniające wartość elementu ................................. 137 4.3. Definiowanie własnych klas .................................................................................. 141 4.3.1. Klasa Employee .......................................................................................... 141 4.3.2. Używanie wielu plików źródłowych ................................................................. 144 4.3.3. Analiza klasy Employee ............................................................................... 144 4.3.4. Pierwsze kroki w tworzeniu konstruktorów ..................................................... 145 4.3.5. Deklarowanie zmiennych lokalnych za pomocą słowa kluczowego var .................. 146 4.3.6. Praca z referencjami null ............................................................................. 147 4.3.7. Parametry jawne i niejawne .......................................................................... 148 4.3.8. Korzyści z hermetyzacji ................................................................................ 149 4.3.9. Przywileje klasowe ...................................................................................... 151 4.3.10. Metody prywatne ....................................................................................... 152 4.3.11. Stałe jako pola klasy ................................................................................. 152 4.4. Pola i metody statyczne ....................................................................................... 153 4.4.1. Pola statyczne ............................................................................................ 153 4.4.2. Stałe statyczne ........................................................................................... 154 4.4.3. Metody statyczne ........................................................................................ 155 4.4.4. Metody fabryczne ........................................................................................ 156 4.4.5. Metoda main .............................................................................................. 156 4.5. Parametry metod ................................................................................................. 159 4.6. Konstruowanie obiektów ...................................................................................... 165 4.6.1. Przeciążanie ............................................................................................... 165 4.6.2. Domyślna inicjalizacja pól ............................................................................ 166 4.6.3. Konstruktor bezargumentowy ....................................................................... 166 4.6.4. Jawna inicjalizacja pól ................................................................................. 167 4.6.5. Nazywanie parametrów ................................................................................ 168 4.6.6. Wywoływanie innego konstruktora ................................................................ 169 4.6.7. Bloki inicjalizujące ....................................................................................... 169 4.6.8. Niszczenie obiektów i metoda finalize ........................................................... 173 4.7. Pakiety ............................................................................................................... 174 4.7.1. Nazwy pakietów .......................................................................................... 174 4.7.2. Importowanie klas ....................................................................................... 175 4.7.3. Importowanie statyczne ............................................................................... 176 4.7.4. Dodawanie klasy do pakietu ........................................................................ 177 4.7.5. Dostęp do pakietu ...................................................................................... 180 4.7.6. Ścieżka klas ............................................................................................... 181 4.7.7. Ustawianie ścieżki klas ............................................................................... 183 Poleć książkęKup książkę 6 Java. Podstawy 4.8. Pliki JAR ............................................................................................................. 184 4.8.1. Tworzenie plików JAR .................................................................................. 184 4.8.2. Manifest .................................................................................................... 184 4.8.3. Wykonywalne pliki JAR ................................................................................. 186 4.8.4. Pliki JAR z wieloma wersjami klas ................................................................. 187 4.8.5. Kilka uwag na temat opcji wiersza poleceń .................................................... 188 4.9. Komentarze dokumentacyjne ............................................................................... 189 4.9.1. Wstawianie komentarzy ............................................................................... 190 4.9.2. Komentarze do klas .................................................................................... 190 4.9.3. Komentarze do metod ................................................................................. 191 4.9.4. Komentarze do pól ...................................................................................... 192 4.9.5. Komentarze ogólne ..................................................................................... 192 4.9.6. Komentarze do pakietów ............................................................................. 193 4.9.7. Pobieranie komentarzy ................................................................................ 194 4.10. Porady dotyczące projektowania klas .................................................................. 195 Rozdział 5. Dziedziczenie .......................................................................................................................199 5.1. Klasy, nadklasy i podklasy ................................................................................... 200 5.1.1. Definiowanie podklas .................................................................................. 200 5.1.2. Przesłanianie metod .................................................................................... 201 5.1.3. Konstruktory podklas .................................................................................. 203 5.1.4. Hierarchia dziedziczenia .............................................................................. 207 5.1.5. Polimorfizm ................................................................................................ 207 5.1.6. Zasady wywoływania metod ......................................................................... 209 5.1.7. Wyłączanie dziedziczenia — klasy i metody finalne ........................................ 211 5.1.8. Rzutowanie ................................................................................................. 212 5.1.9. Klasy abstrakcyjne ...................................................................................... 215 5.1.10. Ograniczanie dostępu ................................................................................ 220 5.2. Kosmiczna klasa wszystkich klas — Object ........................................................... 221 5.2.1. Zmienne typu Object ................................................................................... 221 5.2.2. Metoda equals ........................................................................................... 221 5.2.3. Porównywanie a dziedziczenie ...................................................................... 223 5.2.4. Metoda hashCode ....................................................................................... 226 5.2.5. Metoda toString .......................................................................................... 228 5.3. Generyczne listy tablicowe ................................................................................... 234 5.3.1. Deklarowanie list tablicowych ....................................................................... 234 5.3.2. Dostęp do elementów listy tablicowej ........................................................... 237 5.3.3. Zgodność pomiędzy typowanymi a surowymi listami tablicowymi ..................... 240 5.4. Opakowania obiektów i automatyczne pakowanie ....................................................... 241 5.5. Metody ze zmienną liczbą parametrów .................................................................. 244 5.6. Klasy wyliczeniowe .............................................................................................. 246 5.7. Refleksja ............................................................................................................ 248 5.7.1. Klasa Class ................................................................................................ 248 5.7.2. Podstawy deklarowania wyjątków ................................................................. 251 5.7.3. Zasoby ....................................................................................................... 252 5.7.4. Zastosowanie refleksji w analizie funkcjonalności klasy ................................. 254 5.7.5. Refleksja w analizie obiektów w czasie działania programu ............................. 259 5.7.6. Zastosowanie refleksji w generycznym kodzie tablicowym ............................... 264 5.7.7. Wywoływanie dowolnych metod i konstruktorów ............................................. 267 5.8. Porady projektowe dotyczące dziedziczenia ............................................................ 270 Poleć książkęKup książkę Spis treści 7 Rozdział 6. Interfejsy, wyrażenia lambda i klasy wewnętrzne .........................................................273 6.1. Interfejsy ............................................................................................................ 274 6.1.1. Koncepcja interfejsu .................................................................................... 274 6.1.2. Własności interfejsów .................................................................................. 280 6.1.3. Interfejsy a klasy abstrakcyjne ..................................................................... 281 6.1.4. Metody statyczne i prywatne ........................................................................ 282 6.1.5. Metody domyślne ........................................................................................ 283 6.1.6. Wybieranie między metodami domyślnymi ..................................................... 284 6.1.7. Interfejsy i wywołania zwrotne ...................................................................... 286 6.1.8. Interfejs Comparator ................................................................................... 289 6.1.9. Klonowanie obiektów ................................................................................... 290 6.2. Wyrażenia lambda ............................................................................................... 296 6.2.1. Po co w ogóle są lambdy ............................................................................. 296 6.2.2. Składnia wyrażeń lambda ............................................................................ 297 6.2.3. Interfejsy funkcyjne ..................................................................................... 299 6.2.4. Referencje do metod ................................................................................... 301 6.2.5. Referencje do konstruktorów ........................................................................ 305 6.2.6. Zakres dostępności zmiennych .................................................................... 306 6.2.7. Przetwarzanie wyrażeń lambda ..................................................................... 308 6.2.8. Poszerzenie wiadomości o komparatorach .................................................... 311 6.3. Klasy wewnętrzne ................................................................................................ 312 6.3.1. Dostęp do stanu obiektu w klasie wewnętrznej .............................................. 313 6.3.2. Specjalne reguły składniowe dotyczące klas wewnętrznych ............................. 316 6.3.3. Czy klasy wewnętrzne są potrzebne i bezpieczne? .......................................... 317 6.3.4. Lokalne klasy wewnętrzne ........................................................................... 319 6.3.5. Dostęp do zmiennych finalnych z metod zewnętrznych .................................... 320 6.3.6. Anonimowe klasy wewnętrzne ...................................................................... 321 6.3.7. Statyczne klasy wewnętrzne ......................................................................... 325 6.4. Moduły ładowania usług ....................................................................................... 328 6.5. Klasy pośredniczące ............................................................................................ 331 6.5.1. Kiedy używać klas pośredniczących .............................................................. 331 6.5.2. Tworzenie obiektów pośredniczących ............................................................ 331 6.5.3. Właściwości klas pośredniczących ................................................................ 335 Rozdział 7. Wyjątki, asercje i dzienniki ...............................................................................................337 7.1. Obsługa błędów .................................................................................................. 338 7.1.1. Klasyfikacja wyjątków .................................................................................. 339 7.1.2. Deklarowanie wyjątków kontrolowanych ........................................................ 341 7.1.3. Zgłaszanie wyjątków .................................................................................... 343 7.1.4. Tworzenie klas wyjątków .............................................................................. 344 7.2. Przechwytywanie wyjątków .................................................................................... 345 7.2.1. Przechwytywanie wyjątku ............................................................................. 345 7.2.2. Przechwytywanie wielu typów wyjątków .......................................................... 347 7.2.3. Powtórne generowanie wyjątków i budowanie łańcuchów wyjątków ........................ 348 7.2.4. Klauzula finally ........................................................................................... 350 7.2.5. Instrukcja try z zasobami ............................................................................. 352 7.2.6. Analiza danych ze stosu wywołań ................................................................. 354 7.3. Wskazówki dotyczące stosowania wyjątków ........................................................... 358 7.4. Asercje ............................................................................................................... 360 7.4.1. Koncepcja asercji ........................................................................................ 361 7.4.2. Włączanie i wyłączanie asercji ...................................................................... 362 Poleć książkęKup książkę 8 Java. Podstawy 7.4.3. Zastosowanie asercji do sprawdzania parametrów ......................................... 362 7.4.4. Zastosowanie asercji do dokumentowania założeń ........................................ 364 7.5. Dzienniki ............................................................................................................ 365 7.5.1. Podstawy zapisu do dziennika ...................................................................... 366 7.5.2. Zaawansowane techniki zapisu do dziennika ................................................. 366 7.5.3. Zmiana konfiguracji menedżera dzienników ................................................... 368 7.5.4. Lokalizacja ................................................................................................. 370 7.5.5. Obiekty typu Handler ................................................................................... 371 7.5.6. Filtry .......................................................................................................... 374 7.5.7. Formatery ................................................................................................... 374 7.5.8. Przepis na dziennik ..................................................................................... 375 7.6. Wskazówki dotyczące debugowania ...................................................................... 383 Rozdział 8. Programowanie generyczne ............................................................................................389 8.1. Dlaczego programowanie generyczne .................................................................... 390 8.1.1. Zalety parametrów typów ............................................................................. 390 8.1.2. Dla kogo programowanie generyczne ............................................................ 391 8.2. Definicja prostej klasy generycznej ........................................................................ 392 8.3. Metody generyczne .............................................................................................. 394 8.4. Ograniczenia zmiennych typowych ......................................................................... 396 8.5. Kod generyczny a maszyna wirtualna .................................................................... 398 8.5.1. Wymazywanie typów .................................................................................... 398 8.5.2. Translacja wyrażeń generycznych .................................................................. 399 8.5.3. Translacja metod generycznych .................................................................... 400 8.5.4. Używanie starego kodu ................................................................................ 402 8.6. Ograniczenia i braki ............................................................................................. 403 8.6.1. Nie można podawać typów prostych jako parametrów typowych ...................... 403 8.6.2. Sprawdzanie typów w czasie działania programu jest możliwe tylko dla typów surowych ..................................................................................... 403 8.6.3. Nie można tworzyć tablic typów generycznych ................................................ 404 8.6.4. Ostrzeżenia dotyczące zmiennej liczby argumentów ........................................ 405 8.6.5. Nie wolno tworzyć egzemplarzy zmiennych typowych ....................................... 406 8.6.6. Nie można utworzyć egzemplarza generycznej tablicy ..................................... 407 8.6.7. Zmiennych typowych nie można używać w statycznych kontekstach klas generycznych .............................................................................................. 408 8.6.8. Obiektów klasy generycznej nie można generować ani przechwytywać .............. 409 8.6.9. Można wyłączyć sprawdzanie wyjątków kontrolowanych .................................. 409 8.6.10. Uważaj na konflikty, które mogą powstać po wymazaniu typów ..................... 411 8.7. Zasady dziedziczenia dla typów generycznych ........................................................ 412 8.8. Typy wieloznaczne ............................................................................................... 414 8.8.1. Koncepcja typu wieloznacznego .................................................................... 414 8.8.2. Ograniczenia nadtypów typów wieloznacznych ................................................ 415 8.8.3. Typy wieloznaczne bez ograniczeń ................................................................ 418 8.8.4. Chwytanie typu wieloznacznego .................................................................... 418 8.9. Refleksja a typy generyczne ................................................................................. 421 8.9.1. Generyczna klasa Class ............................................................................... 421 8.9.2. Zastosowanie parametrów Class T do dopasowywania typów ....................... 422 8.9.3. Informacje o typach generycznych w maszynie wirtualnej ................................ 422 8.9.4. Literały typowe ............................................................................................ 426 Poleć książkęKup książkę Spis treści 9 Rozdział 9. Kolekcje ..............................................................................................................................433 9.1. Architektura kolekcji Javy ..................................................................................... 434 9.1.1. Oddzielenie warstwy interfejsów od warstwy klas konkretnych ......................... 434 9.1.2. Interfejs Collection ...................................................................................... 436 9.1.3. Iteratory ..................................................................................................... 437 9.1.4. Generyczne metody użytkowe ....................................................................... 439 9.2. Interfejsy w systemie kolekcji Javy ........................................................................ 442 9.3. Konkretne klasy kolekcyjne .................................................................................. 445 9.3.1. Listy powiązane .......................................................................................... 445 9.3.2. Listy tablicowe ............................................................................................ 454 9.3.3. Zbiór HashSet ............................................................................................ 454 9.3.4. Zbiór TreeSet .............................................................................................. 458 9.3.5. Kolejki Queue i Deque ................................................................................. 462 9.3.6. Kolejki priorytetowe ..................................................................................... 464 9.4. Słowniki ............................................................................................................. 465 9.4.1. Podstawowe operacje słownikowe ................................................................ 465 9.4.2. Modyfikowanie wpisów w słowniku ............................................................... 468 9.4.3. Widoki słowników ........................................................................................ 470 9.4.4. Klasa WeakHashMap .................................................................................. 471 9.4.5. Klasy LinkedHashSet i LinkedHashMap ........................................................ 472 9.4.6. Klasy EnumSet i EnumMap .......................................................................... 473 9.4.7. Klasa IdentityHashMap ............................................................................... 474 9.5. Widoki i opakowania ............................................................................................ 476 9.5.1. Małe kolekcje ............................................................................................. 476 9.5.2. Przedziały ................................................................................................... 478 9.5.3. Widoki niemodyfikowalne ............................................................................. 478 9.5.4. Widoki synchronizowane .............................................................................. 480 9.5.5. Widoki kontrolowane ................................................................................... 480 9.5.6. Uwagi dotyczące operacji opcjonalnych ......................................................... 481 9.6. Algorytmy ............................................................................................................ 485 9.6.1. Dlaczego algorytmy generyczne .................................................................... 485 9.6.2. Sortowanie i tasowanie ............................................................................... 486 9.6.3. Wyszukiwanie binarne ................................................................................. 489 9.6.4. Proste algorytmy ......................................................................................... 490 9.6.5. Operacje zbiorowe ....................................................................................... 492 9.6.6. Konwersja pomiędzy kolekcjami a tablicami .................................................. 493 9.6.7. Pisanie własnych algorytmów ....................................................................... 493 9.7. Stare kolekcje ..................................................................................................... 495 9.7.1. Klasa Hashtable ......................................................................................... 495 9.7.2. Wyliczenia .................................................................................................. 495 9.7.3. Słowniki własności ...................................................................................... 496 9.7.4. Stosy ......................................................................................................... 500 9.7.5. Zbiory bitów ................................................................................................ 500 Rozdział 10. Graficzne interfejsy użytkownika ...................................................................................505 10.1. Historia zestawów narzędzi do tworzenia interfejsów użytkownika .......................... 505 10.2. Wyświetlanie ramki ............................................................................................ 507 10.2.1. Tworzenie ramki ........................................................................................ 507 10.2.2. Właściwości ramki .................................................................................... 509 Poleć książkęKup książkę 10 Java. Podstawy 10.3. Wyświetlanie informacji w komponencie .............................................................. 512 10.3.1. Figury 2D .................................................................................................. 517 10.3.2. Kolory ...................................................................................................... 523 10.3.3. Czcionki ................................................................................................... 524 10.3.4. Wyświetlanie obrazów ................................................................................ 530 10.4. Obsługa zdarzeń ................................................................................................ 531 10.4.1. Podstawowe koncepcje obsługi zdarzeń ...................................................... 531 10.4.2. Przykład — obsługa kliknięcia przycisku ...................................................... 533 10.4.3. Zwięzłe definiowanie procedur nasłuchowych .............................................. 536 10.4.4. Klasy adaptacyjne ..................................................................................... 537 10.4.5. Akcje ....................................................................................................... 539 10.4.6. Zdarzenia generowane przez mysz .............................................................. 545 10.4.7. Hierarchia zdarzeń w bibliotece AWT ........................................................... 550 10.5. API Preferences ................................................................................................ 552 Rozdział 11. Komponenty Swing interfejsu użytkownika ...................................................................559 11.1. Swing i wzorzec model-widok-kontroler ................................................................ 560 11.2. Wprowadzenie do zarządzania rozkładem ............................................................ 563 11.2.1. Zarządcy układu ........................................................................................ 563 11.2.2. Rozkład brzegowy ...................................................................................... 565 11.2.3. Rozkład siatkowy ...................................................................................... 567 11.3. Wprowadzanie tekstu ........................................................................................ 568 11.3.1. Pola tekstowe ........................................................................................... 568 11.3.2. Etykiety komponentów ............................................................................... 570 11.3.3. Pola haseł ................................................................................................ 571 11.3.4. Obszary tekstowe ...................................................................................... 572 11.3.5. Panele przewijane ..................................................................................... 573 11.4. Komponenty umożliwiające wybór opcji ............................................................... 575 11.4.1. Pola wyboru .............................................................................................. 575 11.4.2. Przełączniki .............................................................................................. 577 11.4.3. Obramowanie ........................................................................................... 581 11.4.4. Listy rozwijane .......................................................................................... 583 11.4.5. Suwaki ..................................................................................................... 586 11.5. Menu ............................................................................................................... 592 11.5.1. Tworzenie menu ........................................................................................ 592 11.5.2. Ikony w elementach menu ......................................................................... 595 11.5.3. Pola wyboru i przełączniki jako elementy menu ............................................ 596 11.5.4. Menu podręczne ....................................................................................... 597 11.5.5. Mnemoniki i akceleratory ........................................................................... 598 11.5.6. Aktywowanie i dezaktywowanie elementów menu ......................................... 600 11.5.7. Paski narzędzi .......................................................................................... 604 11.5.8. Dymki ...................................................................................................... 606 11.6. Zaawansowane techniki zarządzania rozkładem ................................................... 607 11.6.1. Rozkład GridBagLayout .............................................................................. 607 11.6.2. Niestandardowi zarządcy rozkładu .............................................................. 616 11.7. Okna dialogowe ................................................................................................ 620 11.7.1. Okna dialogowe opcji ................................................................................ 621 11.7.2. Tworzenie okien dialogowych ..................................................................... 625 11.7.3. Wymiana danych ....................................................................................... 629 11.7.4. Okna dialogowe wyboru plików ................................................................... 634 Poleć książkęKup książkę Spis treści 11 Rozdział 12. Współbieżność ..................................................................................................................643 12.1. Czym są wątki ................................................................................................... 644 12.2. Stany wątków .................................................................................................... 648 12.2.1. Wątki tworzone za pomocą operatora new ................................................... 649 12.2.2. Wątki RUNNABLE ...................................................................................... 649 12.2.3. Wątki BLOCKED i WAITING ......................................................................... 650 12.2.4. Zamykanie wątków .................................................................................... 650 12.3. Własności wątków ............................................................................................. 652 12.3.1. Przerywanie wątków .................................................................................. 652 12.3.2. Wątki demony ........................................................................................... 655 12.3.3. Nazwy wątków .......................................................................................... 655 12.3.4. Procedury obsługi nieprzechwyconych wyjątków ........................................... 655 12.3.5. Priorytety wątków ...................................................................................... 657 12.4. Synchronizacja .................................................................................................. 658 12.4.1. Przykład sytuacji powodującej wyścig .......................................................... 658 12.4.2. Wyścigi .................................................................................................... 660 12.4.3. Obiekty klasy Lock .................................................................................... 662 12.4.4. Warunki ................................................................................................... 665 12.4.5. Słowo kluczowe synchronized ..................................................................... 670 12.4.6. Bloki synchronizowane .............................................................................. 674 12.4.7. Monitor .................................................................................................... 675 12.4.8. Pola ulotne ............................................................................................... 676 12.4.9. Zmienne finalne ........................................................................................ 677 12.4.10. Zmienne atomowe .................................................................................. 677 12.4.11. Zakleszczenia ......................................................................................... 679 12.4.12. Zmienne lokalne wątków ......................................................................... 682 12.4.13. Dlaczego metody stop i suspend są wycofywane ....................................... 683 12.5. Kolekcje bezpieczne wątkowo ............................................................................. 685 12.5.1. Kolejki blokujące ....................................................................................... 685 12.5.2. Szybkie słowniki, zbiory i kolejki ................................................................. 692 12.5.3. Atomowe modyfikowanie elementów słowników ........................................... 693 12.5.4. Operacje masowe na współbieżnych słownikach skrótów .............................. 696 12.5.5. Współbieżne widoki zbiorów ....................................................................... 698 12.5.6. Tablice kopiowane przy zapisie ................................................................... 699 12.5.7. Równoległe algorytmy tablicowe ................................................................. 699 12.5.8. Starsze kolekcje bezpieczne wątkowo ......................................................... 700 12.6. Zadania i pule wątków ....................................................................................... 701 12.6.1. Interfejsy Callable i Future ......................................................................... 702 12.6.2. Klasa Executors ........................................................................................ 704 12.6.3. Kontrolowanie grup zadań .......................................................................... 707 12.6.4. Metoda rozgałęzienie-złączenie .................................................................. 711 12.7. Obliczenia asynchroniczne ................................................................................. 714 12.7.1. Klasa CompletableFuture ........................................................................... 714 12.7.2. Tworzenie obiektów CompletableFuture ....................................................... 716 12.7.3. Czasochłonne zadania w wywołaniach zwrotnych interfejsu użytkownika ........ 722 12.8. Procesy ............................................................................................................ 728 12.8.1. Budowanie procesu ................................................................................... 729 12.8.2. Uruchamianie procesu ............................................................................... 730 12.8.3. Uchwyty procesów ..................................................................................... 731 Dodatek A ...............................................................................................................................................737 Skorowidz ..............................................................................................................................................741 Poleć książkęKup książkę 12 Java. Podstawy Poleć książkęKup książkę 12 Współbieżność W tym rozdziale:  12.1. Czym są wątki  12.2. Stany wątków  12.3. Własności wątków  12.4. Synchronizacja  12.5. Kolekcje bezpieczne wątkowo  12.6. Zadania i pule wątków  12.7. Obliczenia asynchroniczne  12.8. Procesy Większość użytkowników systemów operacyjnych zna pojęcie wielozadaniowości, czyli zdolności systemu do uruchamiania więcej niż jednego programu pozornie jednocześnie. Można na przykład pisać lub wysyłać e-mail i w tym samym czasie drukować jakiś dokument. W dzisiejszych czasach coraz częściej spotyka się komputery wyposażone w więcej niż jeden procesor, choć liczba procesów działających jednocześnie nie jest ograniczona liczbą pro- cesorów. System operacyjny stwarza pozory równoległego wykonywania zadań, każdemu procesowi przydzielając odpowiedni czas pracy procesora. Programy wielowątkowe przenoszą koncepcję wielozadaniowości o jeden poziom niżej, gdzie poszczególne programy sprawiają złudzenie wykonywania wielu zadań naraz. Każde z tych zadań jest zwyczajowo nazywane wątkiem (ang. thread), a pełna nazwa to wątek sterowania (ang. thread of control). Programy potrafiące działać w więcej niż jednym wątku nazywają się programami wielowątkowymi (ang. multithreaded). Jaka jest zatem różnica pomiędzy wieloma procesami a wieloma wątkami? Przede wszystkim należy zauważyć, że każdy proces posiada pełen zestaw własnych zmiennych, podczas gdy wątki współdzielą dane z innymi wątkami. Brzmi to dosyć ryzykownie i rzeczywiście może czasami sprawiać problemy, o czym przekonasz się za chwilę. Z drugiej strony dzięki współ- dzieleniu zmiennych komunikacja pomiędzy wątkami zachodzi sprawniej i jest łatwiejsza do Poleć książkęKup książkę 644 Java. Podstawy zaprogramowania niż komunikacja międzyprocesowa. Ponadto wątki w niektórych systemach operacyjnych są lżejsze od procesów, to znaczy utworzenie i zniszczenie pojedynczego wątku zajmuje mniej czasu niż uruchomienie nowego procesu. Wielowątkowość jest niezwykle praktycznym narzędziem. Wiadomo na przykład, że przeglą- darka powinna mieć możliwość pobierania kilku obrazów jednocześnie, a serwer sieciowy musi obsługiwać wiele żądań w tym samym czasie. Programy z graficznym interfejsem użyt- kownika dysponują osobnym wątkiem do zbierania zdarzeń z interfejsu pochodzących od środowiska operacyjnego. Ten rozdział dotyczy pisania aplikacji wielowątkowych w Javie. Ostrzeżenie: programy wielowątkowe bywają bardzo skomplikowane. My opisujemy wszystkie narzędzia, których może potrzebować programista. Jednak w poszukiwaniu opisów bardziej zaawansowanych technik programowania systemowego odsyłamy do innych źródeł, na przy- kład książki Java. Współbieżność dla praktyków, której autorami są Brian Goetz, Tim Peierls, Joshua Bloch, Joseph Bowbeer, David Holmes i Doug Lea (Helion, Gliwice 2007). 12.1. Czym są wątki Na początek przyjrzymy się prostemu programowi, który wykorzystuje dwa wątki do prze- noszenia pieniędzy między kontami bankowymi. Będziemy używać klasy Bank zapisującej salda określonej liczby kont. Metoda transfer przelewa określoną kwotę z jednego konta na inne. Implementacja jest pokazana na listingu 12.2. W pierwszym wątku przelejemy pieniądze z konta 0 na konto 1. Drugi wątek będzie prze- lewał pieniądze z konta 2 na konto 3. Poniżej znajduje się prosta procedura uruchamiania zadania w osobnym wątku: 1. Umieść kod zadania w metodzie run klasy implementującej interfejs Runnable. Ten bardzo prosty interfejs zawiera tylko jedną metodę: public interface Runnable { void run(); } Dzięki temu, że Runnable to interfejs funkcyjny, można utworzyć egzemplarz za pomocą wyrażenia lambda: Runnable r = () - { task code }; 2. Utwórz obiekt Thread z egzemplarza Runnable: var t = new Thread(r); 3. Uruchom wątek: t.start(); Aby utworzyć osobny wątek do przelewania pieniędzy, należy umieścić kod realizujący przelew w metodzie run egzemplarza Runnable, a następnie uruchomić wątek: Poleć książkęKup książkę Rozdział 12.  Współbieżność 645 Runnable r = () - { try { for (int i = 0; i STEPS; i++) { double amount = MAX_AMOUNT * Math.random(); bank.transfer(0, 1, amount); Thread.sleep((int) (DELAY * Math.random())); } } catch (InterruptedException e) { } }; var t = new Thread(r); t.start(); W określonej liczbie kroków wątek ten przelewa losową kwotę, po czym zasypia na losową ilość czasu. Musimy przechwycić wyjątek InterruptedException, którego zgłoszeniem grozi metoda sleep. Dokładniej tym wyjątkiem zajmujemy się w punkcie 12.3.1, „Przerywanie wątków”. Pracę wątków zazwyczaj przerywa się w celu zakończenia ich działania. W chwili wystąpienia wyjątku InterruptedException nasza metoda run także zakończy działanie. Ponadto nasz program uruchamia drugi wątek, który przelewa pieniądze z konta 2 na konto 3. Poniżej znajduje się wynik działania tego programu: Thread[Thread-1,5,main] 606,77 z 2 na 3 Saldo całkowite: 400000,00 Thread[Thread-0,5,main] 98,99 z 0 na 1 Saldo całkowite: 400000,00 Thread[Thread-1,5,main] 476,78 z 2 na 3 Saldo całkowite: 400000,00 Thread[Thread-0,5,main] 653,64 z 0 na 1 Saldo całkowite: 400000,00 Thread[Thread-1,5,main] 807,14 z 2 na 3 Saldo całkowite: 400000,00 Thread[Thread-0,5,main] 481,49 z 0 na 1 Saldo całkowite: 400000,00 Thread[Thread-0,5,main] 203,73 z 0 na 1 Saldo całkowite: 400000,00 Thread[Thread-1,5,main] 111,76 z 2 na 3 Saldo całkowite: 400000,00 Thread[Thread-1,5,main] 794,88 z 2 na 3 Saldo całkowite: 400000,00 . . . Wyniki dwóch wątków przeplatają się, co wskazuje na to, że wątki te są wykonywane współ- bieżnie. Czasami jednak wyniki takiej przeplatanki mogą być mniej uporządkowane. To wszystko! Od tej pory umiesz wykonywać zadania współbieżnie. W pozostałej części tego rozdziału znajduje się opis technik kontroli interakcji między wątkami. Na listingu 12.1 znajduje się kompletny kod. Listing 12.1. threads/ThreadTest.java package threads; /** * @version 1.30 2004-08-01 * @author Cay Horstmann Poleć książkęKup książkę 646 Java. Podstawy */ public class ThreadTest { public static final int DELAY = 10; public static final int STEPS = 100; public static final double MAX_AMOUNT = 1000; public static void main(String[] args) { var bank = new Bank(4, 100000); Runnable task1 = () - { try { for (int i = 0; i STEPS; i++) { double amount = MAX_AMOUNT * Math.random(); bank.transfer(0, 1, amount); Thread.sleep((int) (DELAY * Math.random())); } } catch (InterruptedException e) { } }; Runnable task2 = () - { try { for (int i = 0; i STEPS; i++) { double amount = MAX_AMOUNT * Math.random(); bank.transfer(2, 3, amount); Thread.sleep((int) (DELAY * Math.random())); } } catch (InterruptedException e) { } }; new Thread(task1).start(); new Thread(task2).start(); } } Wątek można też zdefiniować poprzez utworzenie podklasy klasy Thread, np.: class MyThread extends Thread { public void run() { task code } } Poleć książkęKup książkę Rozdział 12.  Współbieżność 647 Następnie można utworzyć obiekt podklasy i wywołać jego metodę start. Technika ta nie jest jednak już zalecana, ponieważ powinno się oddzielać zadanie do wykonania rów- noległego od mechanizmu wykonywania. Jeśli zadań jest dużo, tworzenie osobnego wąt- ku dla każdego z nich jest zbyt kosztowne. W takim przypadku lepiej użyć puli wątków — patrz punkt 12.6.2, „Klasa Executors”. Nie wywołuj metody run klasy Thread ani obiektu typu Runnable. Jej bezpośrednie wywołanie powoduje tylko wykonanie zadania i tym samym wątku — nie zostaje uruchomiony nowy wątek. Zamiast tego należy wywołać metodę Thread.start, która two- rzy nowy wątek wykonujący metodę run. Listing 12.2. threads/Bank.java package threads; import java.util.*; /** * Bank z pewną liczbą kont. */ public class Bank { private final double[] accounts; /** * Tworzy bank. * @param n liczba kont * @param initialBalance początkowe saldo każdego konta */ public Bank(int n, double initialBalance) { accounts = new double[n]; Arrays.fill(accounts, initialBalance); } /** * Przelewa pieniądze z jednego konta na inne. * @param from konto źródłowe * @param to konto docelowe * @param amount kwota przelewu */ public void transfer(int from, int to, double amount) { if (accounts[from] amount) return; System.out.print(Thread.currentThread()); accounts[from] -= amount; System.out.printf( 10.2f z d na d , amount, from, to); accounts[to] += amount; System.out.printf( Saldo całkowite: 10.2f n , getTotalBalance()); } /** * Oblicza sumę wszystkich sald kont. * @return saldo całkowite */ Poleć książkęKup książkę 648 Java. Podstawy public double getTotalBalance() { double sum = 0; for (double a : accounts) sum += a; return sum; } /** * Sprawdza liczbę kont w banku. * @return liczba kont */ public int size() { return accounts.length; } } java.lang.Thread 1.0  Thread(Runnable target) Tworzy nowy wątek, który wywołuje metodę run() wskazanego obiektu.  void start() Uruchamia ten wątek, powodując wywołanie metody run(). Metoda ta zwraca wartość natychmiast. Nowy wątek działa współbieżnie.  void run() Wywołuje metodę run powiązanego obiektu typu Runnable.  static void sleep(long millis) Zatrzymuje wykonywanie na określoną liczbę milisekund. java.lang.Runnable 1.0  void run() Metoda, która musi zostać przesłonięta oraz otrzymać wytyczne dla zadania, które ma zostać wykonane. 12.2. Stany wątków Wątek może być w jednym z sześciu stanów:  NEW (nowy),  RUNNABLE (wykonywalny),  BLOCKED (zablokowany), Poleć książkęKup książkę Rozdział 12.  Współbieżność 649  WAITING (oczekujący),  TIMED WAITING (oczekujący określoną ilość czasu),  TERMINATED (zakończony). Znaczenie tych wszystkich stanów zostało opisane poniżej. Do sprawdzania aktualnego stanu wątku służy metoda getState. 12.2.1. Wątki tworzone za pomocą operatora new Wątek utworzony za pomocą operatora new — na przykład new Thread(r) — nie jest od razu uruchamiany. Oznacza to, że pozostaje on w stanie NEW. Jeśli wątek znajduje się w stanie NEW, program nie zaczął jeszcze wykonywać znajdującego się w nim kodu. Przed uruchomieniem wątku trzeba wykonać jeszcze kilka dodatkowych czynności. 12.2.2. Wątki RUNNABLE Po wywołaniu metody start wątek przechodzi w stan RUNNABLE. Wątek taki może, ale nie musi być uruchomiony. Przydział czasu dla wątku leży w gestii systemu operacyjnego (w Javie dla stanu działania wątku nie wprowadzono osobnej nazwy, dlatego uruchomiony wątek nadal pozostaje w stanie RUNNABLE). Po uruchomieniu wątek nie musi działać cały czas. Zaleca się nawet wstrzymywanie działają- cych wątków co jakiś czas, aby dać szansę na działanie innym wątkom. Szczegółowa kon- trola harmonogramu wykonywania wątków zależy od usług udostępnianych przez system operacyjny. Systemy planowania wywłaszczającego wątków przydzielają każdemu wyko- nywalnemu wątkowi określoną ilość czasu na wykonanie zadania. Kiedy czas mija, system operacyjny wywłaszcza wątek i przydziela czas innemu wątkowi (zobacz rysunek 12.2). Przy wybieraniu kolejnego wątku system operacyjny kieruje się priorytetami wątków — zobacz punkt 12.3.5, „Priorytety wątków”. Wszystkie nowoczesne systemy operacyjne — zarówno serwerowe, jak i przeznaczone na komputery osobiste — stosują planowanie wywłaszczające. Mniejsze urządzenia, jak telefony komórkowe, mogą wykorzystywać planowanie kooperacyjne. W takim urządzeniu wątek traci sterowanie, jeśli wywoła metodę yield lub zosta
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Java. Podstawy. Wydanie XI
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ą: