Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00414 004864 14473192 na godz. na dobę w sumie
Java. Przewodnik dla początkujących. Wydanie V - książka
Java. Przewodnik dla początkujących. Wydanie V - książka
Autor: Liczba stron: 592
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-3919-9 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook, audiobook).

Chcesz nauczyć się Javy?
Zacznij już dziś!

Java to język przeznaczony do realizacji najtrudniejszych programistycznych zadań. Świetnie sprawdza się wszędzie tam, gdzie wymagane są najwyższa wydajność, niezawodność i bezpieczeństwo. Dzięki jasno sprecyzowanym zasadom, przejrzystej składni i silnemu typowaniu jest językiem łatwym w nauce i odpornym na błędy początkujących programistów. Java ma jeszcze jedną zaletę - programiści znający ten język są poszukiwani na rynku pracy w każdej ilości. Chcesz dołączyć do tego grona?

To nie jest trudne! Na początek wystarczy Ci ta książka. Dzięki niej wejdziesz w świat Javy, klas, obiektów, polimorfizmu... Poznasz zalety i wady tego języka oraz to, jak wypada on na tle konkurencyjnych rozwiązań. Następnie zaznajomisz się ze składnią, typami danych, strukturą programu oraz mechanizmem wyjątków. Kolejne rozdziały zawierają bezcenne informacje na temat tworzenia interfejsu użytkownika, dokumentowania kodu i radzenia sobie z typowymi problemami. Ta książka gwarantuje bezbolesne rozpoczęcie przygody z językiem Java!

Zaprojektowana do łatwej nauki!

Najlepszy podręcznik dla początkującego programisty!


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

Darmowy fragment publikacji:

Tytuł oryginału: Java, A Beginner s Guide, 5th Edition Tłumaczenie: Jaromir Senczyk ISBN: 978-83-246-3919-9 Original edition copyright © 2012 by The McGraw-Hill Companies, Inc. All rights reserved. Polish edition copyright © 2012 by HELION SA All rights reserved. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/javpp5.zip Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/javpp5 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treĈci O autorze ................................................................................................. 11 O redaktorze technicznym ........................................................................ 11 Wstöp ...................................................................................................... 13 Rozdziaä 1. Podstawy Javy ......................................................................................... 19 Pochodzenie Javy ........................................................................................................................20 Java a jĊzyki C i C++ ............................................................................................................21 Java a C# ...............................................................................................................................22 Java a Internet ..............................................................................................................................22 Aplety Java ............................................................................................................................22 BezpieczeĔstwo .....................................................................................................................23 PrzenoĞnoĞü ...........................................................................................................................23 Magiczny kod bajtowy ................................................................................................................24 Terminologia Javy .......................................................................................................................25 Programowanie obiektowe ..........................................................................................................26 Hermetyzacja .........................................................................................................................27 Polimorfizm ...........................................................................................................................28 Dziedziczenie ........................................................................................................................28 Java Development Kit .................................................................................................................29 Pierwszy prosty program .............................................................................................................30 Wprowadzenie tekstu programu ............................................................................................30 Kompilowanie programu .......................................................................................................31 Pierwszy program wiersz po wierszu ....................................................................................31 Obsáuga báĊdów skáadni ...............................................................................................................34 Drugi prosty program ..................................................................................................................35 Inne typy danych .........................................................................................................................37 Przykáad 1.1. Zamiana galonów na litry ......................................................................................38 Dwie instrukcje sterujące .............................................................................................................39 Instrukcja if ...........................................................................................................................40 PĊtla for .................................................................................................................................41 Bloki kodu ...................................................................................................................................43 ĝrednik i pozycja kodu w wierszu ...............................................................................................44 WciĊcia ........................................................................................................................................45 Przykáad 1.2. Ulepszony konwerter galonów na litry ..................................................................45 Sáowa kluczowe jĊzyka Java .......................................................................................................46 Identyfikatory ..............................................................................................................................47 Biblioteki klas ..............................................................................................................................48 Test sprawdzający .......................................................................................................................48 4 Java. Przewodnik dla poczñtkujñcych Rozdziaä 2. Typy danych i operatory ............................................................................ 49 Dlaczego typy danych są tak waĪne ............................................................................................50 Typy podstawowe ........................................................................................................................50 Typy caákowite ......................................................................................................................51 Typy zmiennoprzecinkowe ...................................................................................................52 Znaki .....................................................................................................................................53 Typ logiczny ................................................................................................................................54 Przykáad 2.1. Jak daleko uderzyá piorun? ....................................................................................55 Literaáy ........................................................................................................................................56 Literaáy szesnastkowe, ósemkowe i binarne ..........................................................................57 Specjalne sekwencje znaków ................................................................................................57 Literaáy áaĔcuchowe ..............................................................................................................58 Zmienne .......................................................................................................................................59 Inicjalizacja zmiennej ............................................................................................................59 Dynamiczna inicjalizacja ......................................................................................................60 ZasiĊg deklaracji i czas istnienia zmiennych ...............................................................................60 Operatory .....................................................................................................................................63 Operatory arytmetyczne ..............................................................................................................63 Inkrementacja i dekrementacja ..............................................................................................65 Operatory relacyjne i logiczne .....................................................................................................66 Warunkowe operatory logiczne ...................................................................................................67 Operator przypisania ....................................................................................................................69 Skrótowe operatory przypisania ..................................................................................................69 Konwersje typów w instrukcjach przypisania .............................................................................71 Rzutowanie typów niezgodnych ..................................................................................................72 Priorytet operatorów ....................................................................................................................74 Przykáad 2.2. Tabela prawdy dla operatorów logicznych ............................................................74 WyraĪenia ....................................................................................................................................75 Konwersja typów w wyraĪeniach ..........................................................................................76 OdstĊpy i nawiasy .................................................................................................................77 Test sprawdzający .......................................................................................................................78 Rozdziaä 3. Instrukcje sterujñce ................................................................................. 79 Wprowadzanie znaków z klawiatury ...........................................................................................79 Instrukcja if ..................................................................................................................................81 ZagnieĪdĪanie instrukcji if ..........................................................................................................82 Drabinka if-else-if .......................................................................................................................83 Instrukcja switch ..........................................................................................................................84 ZagnieĪdĪanie instrukcji switch ...................................................................................................88 Przykáad 3.1. Rozpoczynamy budowĊ systemu pomocy .............................................................88 PĊtla for .......................................................................................................................................90 Wariacje na temat pĊtli for ..........................................................................................................92 Brakujące elementy .....................................................................................................................93 PĊtla nieskoĔczona ................................................................................................................94 PĊtle bez ciaáa ..............................................................................................................................94 Deklaracja zmiennych sterujących wewnątrz pĊtli ......................................................................95 Rozszerzona pĊtla for ..................................................................................................................96 PĊtla while ...................................................................................................................................96 PĊtla do-while ..............................................................................................................................97 Przykáad 3.2. Ulepszamy system pomocy ...................................................................................99 Przerywanie pĊtli instrukcją break .............................................................................................102 Zastosowanie break jako formy goto .........................................................................................104 Zastosowanie instrukcji continue ...............................................................................................108 Przykáad 3.3. KoĔcowa wersja systemu pomocy .......................................................................109 Spis treĈci 5 PĊtle zagnieĪdĪone ....................................................................................................................112 Test sprawdzający .....................................................................................................................113 Rozdziaä 4. Wprowadzenie do klas, obiektów i metod ................................................ 115 Podstawy klas ............................................................................................................................116 Ogólna postaü klasy ............................................................................................................116 Definiowanie klasy ..............................................................................................................117 Jak powstają obiekty ..................................................................................................................120 Referencje obiektów i operacje przypisania ..............................................................................120 Metody ......................................................................................................................................121 Dodajemy metodĊ do klasy Vehicle ....................................................................................122 Powrót z metody ........................................................................................................................124 Zwracanie wartoĞci ....................................................................................................................125 Stosowanie parametrów .............................................................................................................127 Dodajemy sparametryzowaną metodĊ do klasy Vehicle .....................................................128 Przykáad 4.1. System pomocy jako klasa ...................................................................................130 Konstruktory ..............................................................................................................................135 Konstruktory z parametrami ......................................................................................................136 Dodajemy konstruktor do klasy Vehicle ....................................................................................137 Operator new .............................................................................................................................138 Odzyskiwanie nieuĪytków i metoda finalize() ...........................................................................139 Metoda finalize() .......................................................................................................................139 Przykáad 4.2. Ilustracja dziaáania odzyskiwania nieuĪytków i metody finalize() ......................140 Sáowo kluczowe this ..................................................................................................................142 Test sprawdzający .....................................................................................................................144 Rozdziaä 5. Wiöcej typów danych i operatorów .......................................................... 145 Tablice .......................................................................................................................................145 Tablice jednowymiarowe ....................................................................................................146 Przykáad 5.1. Sortowanie tablicy ...............................................................................................149 Tablice wielowymiarowe ..........................................................................................................151 Tablice dwuwymiarowe ......................................................................................................151 Tablice nieregularne ..................................................................................................................152 Tablice o trzech i wiĊcej wymiarach ...................................................................................153 Inicjalizacja tablic wielowymiarowych ...............................................................................153 Alternatywna skáadnia deklaracji tablic .....................................................................................155 Przypisywanie referencji tablic ..................................................................................................155 Wykorzystanie skáadowej length ...............................................................................................156 Przykáad 5.2. Klasa Queue .........................................................................................................158 Styl for-each pĊtli for .................................................................................................................162 Iteracje w tablicach wielowymiarowych .............................................................................165 Zastosowania rozszerzonej pĊtli for ....................................................................................166 àaĔcuchy znaków ......................................................................................................................167 Tworzenie áaĔcuchów ..........................................................................................................167 Operacje na áaĔcuchach .......................................................................................................168 Tablice áaĔcuchów ...............................................................................................................170 àaĔcuchy są niezmienne .....................................................................................................171 àaĔcuchy sterujące instrukcją switch ..................................................................................172 Wykorzystanie argumentów wywoáania programu ...................................................................173 Operatory bitowe .......................................................................................................................175 Operatory bitowe AND, OR, XOR i NOT ..........................................................................175 Operatory przesuniĊcia ........................................................................................................179 Skrótowe bitowe operatory przypisania ..............................................................................181 Przykáad 5.3. Klasa ShowBits ...................................................................................................182 6 Java. Przewodnik dla poczñtkujñcych Operator ? ..................................................................................................................................184 Test sprawdzający .....................................................................................................................186 Rozdziaä 6. Wiöcej o metodach i klasach .................................................................. 189 Kontrola dostĊpu do skáadowych klasy .....................................................................................189 Modyfikatory dostĊpu w Javie ............................................................................................190 Przykáad 6.1. Ulepszamy klasĊ Queue .......................................................................................194 Przekazywanie obiektów metodom ...........................................................................................195 Sposób przekazywania argumentów ...................................................................................196 Zwracanie obiektów ..................................................................................................................199 PrzeciąĪanie metod ....................................................................................................................201 PrzeciąĪanie konstruktorów .......................................................................................................205 Przykáad 6.2. PrzeciąĪamy konstruktor klasy Queue .................................................................207 Rekurencja .................................................................................................................................210 Sáowo kluczowe static ...............................................................................................................212 Bloki static ..........................................................................................................................215 Przykáad 6.3. Algorytm Quicksort .............................................................................................216 Klasy zagnieĪdĪone i klasy wewnĊtrzne ....................................................................................218 Zmienne liczby argumentów .....................................................................................................221 Metody o zmiennej liczbie argumentów ..............................................................................222 PrzeciąĪanie metod o zmiennej liczbie argumentów ...........................................................225 Zmienna liczba argumentów i niejednoznacznoĞü ..............................................................226 Test sprawdzający .....................................................................................................................227 Rozdziaä 7. Dziedziczenie ......................................................................................... 229 Podstawy dziedziczenia .............................................................................................................230 DostĊp do skáadowych a dziedziczenie ......................................................................................232 Konstruktory i dziedziczenie .....................................................................................................235 UĪycie sáowa kluczowego super do wywoáania konstruktora klasy bazowej ............................237 UĪycie sáowa kluczowego super do dostĊpu do skáadowych klasy bazowej .............................240 Przykáad 7.1. Tworzymy hierarchiĊ klas Vehicle ......................................................................241 Wielopoziomowe hierarchie klas ...............................................................................................244 Kiedy wywoáywane są konstruktory? ........................................................................................247 Referencje klasy bazowej i obiekty klasy pochodnej .................................................................248 Przesáanianie metod ...................................................................................................................252 Przesáanianie metod i polimorfizm ............................................................................................255 Po co przesáaniaü metody? ........................................................................................................257 Zastosowanie przesáaniania metod w klasie TwoDShape ...................................................257 Klasy abstrakcyjne .....................................................................................................................260 Sáowo kluczowe final ................................................................................................................264 final zapobiega przesáanianiu ..............................................................................................264 final zapobiega dziedziczeniu ..............................................................................................265 UĪycie final dla zmiennych skáadowych .............................................................................265 Klasa Object ..............................................................................................................................267 Test sprawdzający .....................................................................................................................268 Rozdziaä 8. Pakiety i interfejsy ................................................................................. 269 Pakiety .......................................................................................................................................269 Definiowanie pakietu ..........................................................................................................270 Wyszukiwanie pakietów i zmienna CLASSPATH ..............................................................271 Prosty przykáad pakietu .......................................................................................................272 Pakiety i dostĊp do skáadowych .................................................................................................273 Przykáad dostĊpu do pakietu ................................................................................................274 Skáadowe protected ...................................................................................................................275 Import pakietów .........................................................................................................................277 Spis treĈci 7 Biblioteka klas Java uĪywa pakietów ........................................................................................279 Interfejsy ....................................................................................................................................279 Implementacje interfejsów .........................................................................................................281 Referencje interfejsu ..................................................................................................................284 Przykáad 8.1. Tworzymy interfejs Queue ..................................................................................286 Zmienne w interfejsach .............................................................................................................290 Interfejsy mogą dziedziczyü ......................................................................................................291 Test sprawdzający .....................................................................................................................293 Rozdziaä 9. Obsäuga wyjñtków .................................................................................. 295 Hierarchia wyjątków ..................................................................................................................296 Podstawy obsáugi wyjątków ......................................................................................................296 Sáowa kluczowe try i catch ..................................................................................................297 Prosty przykáad wyjątku ......................................................................................................298 Konsekwencje nieprzechwycenia wyjątku ................................................................................300 Wyjątki umoĪliwiają obsáugĊ báĊdów .................................................................................301 UĪycie wielu klauzul catch ..................................................................................................302 Przechwytywanie wyjątków klas pochodnych ..........................................................................303 ZagnieĪdĪanie bloków try .........................................................................................................304 Generowanie wyjątku ................................................................................................................305 Powtórne generowanie wyjątku ..........................................................................................306 Klasa Throwable ........................................................................................................................307 Klauzula finally .........................................................................................................................309 UĪycie klauzuli throws ..............................................................................................................311 NowoĞci w JDK 7 ......................................................................................................................312 Wyjątki wbudowane w JavĊ ......................................................................................................313 Tworzenie klas pochodnych wyjątków ......................................................................................315 Przykáad 9.1. Wprowadzamy wyjątki w klasie Queue ...............................................................317 Test sprawdzający .....................................................................................................................320 Rozdziaä 10. Obsäuga wejĈcia i wyjĈcia ....................................................................... 323 Strumienie wejĞcia i wyjĞcia .....................................................................................................324 Strumienie bajtowe i strumienie znakowe .................................................................................324 Klasy strumieni bajtowych ........................................................................................................325 Klasy strumieni znakowych .......................................................................................................326 Strumienie predefiniowane ........................................................................................................326 UĪywanie strumieni bajtowych .................................................................................................327 Odczyt wejĞcia konsoli ........................................................................................................328 Zapis do wyjĞcia konsoli .....................................................................................................329 Odczyt i zapis plików za pomocą strumieni bajtowych .............................................................330 Odczyt z pliku .....................................................................................................................330 Zapis w pliku .......................................................................................................................334 Automatyczne zamykanie pliku .................................................................................................336 Odczyt i zapis danych binarnych ...............................................................................................339 Przykáad 10.1. NarzĊdzie do porównywania plików .................................................................341 Pliki o dostĊpie swobodnym ......................................................................................................343 Strumienie znakowe ..................................................................................................................345 Odczyt konsoli za pomocą strumieni znakowych ................................................................345 Obsáuga wyjĞcia konsoli za pomocą strumieni znakowych .................................................349 Obsáuga plików za pomocą strumieni znakowych .....................................................................350 Klasa FileWriter ..................................................................................................................350 Klasa FileReader .................................................................................................................351 Zastosowanie klas opakowujących do konwersji áaĔcuchów numerycznych ............................352 Przykáad 10.2. System pomocy wykorzystujący pliki ...............................................................355 Test sprawdzający .....................................................................................................................361 8 Java. Przewodnik dla poczñtkujñcych Rozdziaä 11. Programowanie wielowñtkowe ................................................................ 363 Podstawy wielowątkowoĞci .......................................................................................................364 Klasa Thread i interfejs Runnable .............................................................................................365 Tworzenie wątku .......................................................................................................................365 Drobne usprawnienia ...........................................................................................................369 Przykáad 11.1. Tworzymy klasĊ pochodną klasy Thread ...........................................................370 Tworzenie wielu wątków ...........................................................................................................372 Jak ustaliü, kiedy wątek zakoĔczyá dziaáanie? ...........................................................................375 Priorytety wątków .....................................................................................................................378 Synchronizacja ..........................................................................................................................380 Synchronizacja metod ................................................................................................................381 Synchronizacja instrukcji ..........................................................................................................384 Komunikacja miĊdzywątkowa ...................................................................................................386 Przykáad uĪycia metod wait() i notify() ...............................................................................387 Wstrzymywanie, wznawianie i koĔczenie dziaáania wątków ....................................................392 Przykáad 11.2. Wykorzystanie gáównego wątku ........................................................................396 Test sprawdzający .....................................................................................................................397 Rozdziaä 12. Typy wyliczeniowe, automatyczne opakowywanie, import skäadowych statycznych i adnotacje ............................................. 399 Wyliczenia .................................................................................................................................400 Podstawy wyliczeĔ ..............................................................................................................400 Wyliczenia są klasami ...............................................................................................................403 Metody values() i valueOf() ......................................................................................................403 Konstruktory, metody, zmienne instancji a wyliczenia .............................................................404 Dwa waĪne ograniczenia .....................................................................................................406 Typy wyliczeniowe dziedziczą po klasie Enum ........................................................................406 Przykáad 12.1. Komputerowo sterowana sygnalizacja Ğwietlna ................................................408 Automatyczne opakowywanie ...................................................................................................413 Typy opakowujące .....................................................................................................................413 Podstawy automatycznego opakowywania ................................................................................415 Automatyczne opakowywanie i metody ....................................................................................416 Automatyczne opakowywanie i wyraĪenia ................................................................................418 Przestroga ............................................................................................................................419 Import skáadowych statycznych .................................................................................................420 Adnotacje (metadane) ................................................................................................................422 Test sprawdzający .....................................................................................................................425 Rozdziaä 13. GenerycznoĈè ......................................................................................... 427 Podstawy generycznoĞci ............................................................................................................428 Prosty przykáad generycznoĞci ..................................................................................................428 GenerycznoĞü dotyczy tylko obiektów ................................................................................432 Typy generyczne róĪnią siĊ dla róĪnych argumentów .........................................................432 Klasa generyczna o dwóch parametrach ..............................................................................433 Ogólna postaü klasy generycznej ........................................................................................434 Ograniczanie typów ...................................................................................................................434 Stosowanie argumentów wieloznacznych .................................................................................438 Ograniczanie argumentów wieloznacznych ...............................................................................440 Metody generyczne ...................................................................................................................443 Konstruktory generyczne ...........................................................................................................445 Interfejsy generyczne .................................................................................................................445 Przykáad 13.1. Generyczna klasa Queue ....................................................................................448 Typy surowe i tradycyjny kod ...................................................................................................452 Wnioskowanie typów i operator diamentowy ...........................................................................455 Wymazywanie ...........................................................................................................................456 Spis treĈci 9 BáĊdy niejednoznacznoĞci .........................................................................................................457 Ograniczenia związane z generycznoĞcią ..................................................................................458 Zakaz tworzenia instancji parametru okreĞlającego typ ......................................................458 Ograniczenia dla skáadowych statycznych ..........................................................................458 Ograniczenia tablic generycznych .......................................................................................459 Ograniczenia związane z wyjątkami ...................................................................................460 Dalsze studiowanie zagadnienia generycznoĞci .........................................................................460 Test sprawdzający .....................................................................................................................461 Rozdziaä 14. Aplety, zdarzenia i pozostaäe säowa kluczowe .......................................... 463 Podstawy apletów ......................................................................................................................464 Organizacja apletów i podstawowe elementy ............................................................................467 Architektura apletu ....................................................................................................................467 Kompletny szkielet apletu .........................................................................................................468 RozpoczĊcie i zakoĔczenie dziaáania apletu ..............................................................................469 ĩądanie odrysowania .................................................................................................................470 Metoda update() ..................................................................................................................471 Przykáad 14.1. Prosty aplet wyĞwietlający baner .......................................................................471 Wykorzystanie okna statusu ......................................................................................................475 Parametry apletów .....................................................................................................................475 Klasa Applet ..............................................................................................................................477 Obsáuga zdarzeĔ ........................................................................................................................479 Model delegacji zdarzeĔ ............................................................................................................479 Zdarzenia ...................................................................................................................................479 ħródáa zdarzeĔ .....................................................................................................................479 Sáuchacze zdarzeĔ ...............................................................................................................480 Klasy zdarzeĔ ......................................................................................................................480 Interfejsy sáuchaczy zdarzeĔ ................................................................................................480 Wykorzystanie modelu delegacji zdarzeĔ ..................................................................................481 Obsáuga zdarzeĔ myszy .......................................................................................................482 Prosty aplet obsáugujący zdarzenia myszy ..........................................................................483 Inne sáowa kluczowe Javy .........................................................................................................486 Modyfikatory transient i volatile .........................................................................................486 Operator instanceof .............................................................................................................486 Sáowo kluczowe strictfp ......................................................................................................487 Sáowo kluczowe assert ........................................................................................................487 Metody natywne ..................................................................................................................488 Test sprawdzający .....................................................................................................................490 Rozdziaä 15. Wprowadzenie do Swing ......................................................................... 491 Pochodzenie i filozofia Swing ...................................................................................................492 Komponenty i kontenery ...........................................................................................................494 Komponenty ........................................................................................................................494 Kontenery ............................................................................................................................495 Panele kontenerów szczytowych .........................................................................................495 MenedĪery ukáadu .....................................................................................................................496 Pierwszy program wykorzystujący Swing .................................................................................497 Pierwszy program Swing wiersz po wierszu .......................................................................498 Komponent JButton ...................................................................................................................502 Komponent JTextField ..............................................................................................................506 Komponent JCheckBox .............................................................................................................509 Komponent JList .......................................................................................................................512 Przykáad 15.1. Porównywanie plików — aplikacja Swing ........................................................516 Wykorzystanie anonimowych klas wewnĊtrznych do obsáugi zdarzeĔ .....................................521 Aplety Swing .............................................................................................................................522 10 Java. Przewodnik dla poczñtkujñcych Co dalej? ....................................................................................................................................524 Test sprawdzający .....................................................................................................................525 Dodatek A Rozwiñzania testów sprawdzajñcych ....................................................... 527 Rozdziaá 1. Podstawy Javy ........................................................................................................527 Rozdziaá 2. Typy danych i operatory .........................................................................................529 Rozdziaá 3. Instrukcje sterujące .................................................................................................531 Rozdziaá 4. Wprowadzenie do klas, obiektów i metod ..............................................................533 Rozdziaá 5. WiĊcej typów danych i operatorów ........................................................................535 Rozdziaá 6. WiĊcej o metodach i klasach ..................................................................................538 Rozdziaá 7. Dziedziczenie .........................................................................................................543 Rozdziaá 8. Pakiety i interfejsy ..................................................................................................545 Rozdziaá 9. Obsáuga wyjątków ..................................................................................................546 Rozdziaá 10. Obsáuga wejĞcia i wyjĞcia .....................................................................................549 Rozdziaá 11. Programowanie wielowątkowe .............................................................................552 Rozdziaá 12. Typy wyliczeniowe, automatyczne opakowywanie, import skáadowych statycznych i adnotacje ..........................................................554 Rozdziaá 13. GenerycznoĞü .......................................................................................................558 Rozdziaá 14. Aplety, zdarzenia i pozostaáe sáowa kluczowe ......................................................562 Rozdziaá 15. Wprowadzenie do Swing ......................................................................................567 Dodatek B Komentarze dokumentacyjne .................................................................. 573 Znaczniki javadoc ......................................................................................................................573 @author ...............................................................................................................................574 {@code} ..............................................................................................................................575 @deprecated ........................................................................................................................575 {@docRoot} ........................................................................................................................575 @exception .........................................................................................................................575 {@inheritDoc} ....................................................................................................................575 {@link} ...............................................................................................................................575 {@linkplain} .......................................................................................................................576 {@literal} ............................................................................................................................576 @param ...............................................................................................................................576 @return ...............................................................................................................................576 @see ....................................................................................................................................576 @serial ................................................................................................................................577 @serialData .........................................................................................................................577 @serialField ........................................................................................................................577 @since .................................................................................................................................577 @throws ..............................................................................................................................577 {@value} .............................................................................................................................578 @version .............................................................................................................................578 Ogólna postaü komentarza dokumentacyjnego ..........................................................................578 Wynik dziaáania programu javadoc ...........................................................................................579 Przykáad uĪycia komentarzy dokumentacyjnych .......................................................................579 Skorowidz .............................................................................................. 581 Rozdziaä 11. Programowanie wielowñtkowe W tym rozdziale poznasz:  podstawy wielowątkowoĞci,  klasĊ Thread i interfejs Runnable,  tworzenie wątku,  tworzenie wielu wątków,  sposób ustalania zakoĔczenia wątku,  korzystanie z priorytetów wątków,  synchronizacjĊ wątków,  synchronizacjĊ metod,  synchronizacjĊ bloków,  komunikacjĊ miĊdzywątkową,  wstrzymywanie, wznawianie i koĔczenie dziaáania wątków. ChociaĪ Java dostarcza programistom wielu innowacyjnych moĪliwoĞci, to z pewnoĞcią jedną z najbardziej ekscytujących jest obsáuga programowania wielowątkowego. Program wie- lowątkowy zawiera dwie lub wiĊcej czĊĞci, które mogą dziaáaü równolegle. KaĪdą z tych czĊĞci nazywamy wątkiem, a kaĪdy wątek definiuje osobną ĞcieĪkĊ wykonania. Wielowątko- woĞü jest zatem szczególną formą wielozadaniowoĞci. 364 Java. Przewodnik dla poczñtkujñcych Podstawy wielowñtkowoĈci Istnieją dwa podstawowe typy wielozadaniowoĞci, z których jeden opiera siĊ na procesach, a drugi wykorzystuje wątki. WaĪne jest, abyĞ zrozumiaá róĪnice miĊdzy nimi. Proces odpo- wiada w zasadzie wykonywanemu programowi. Zatem wielozadaniowoĞü wykorzystująca procesy umoĪliwia Twojemu komputerowi równolegáe wykonywanie dwóch lub wiĊcej pro- gramów. Wykorzystanie procesów umoĪliwi Ci na przykáad uruchomienie kompilatora Javy w tym samym czasie, gdy piszesz kod Ĩródáowy w edytorze lub przeglądasz strony w Internecie. W przypadku wielozadaniowoĞci wykorzystującej procesy program jest najmniejszą jednostką kodu podlegającą szeregowaniu do wykonania przez procesor. W drugim rodzaju wielozadaniowoĞci najmniejszą jednostką kodu szeregowaną przez system jest wątek. Oznacza to, Īe pojedynczy program moĪe równoczeĞnie wykonywaü dwa lub wiĊcej wątków. Na przykáad edytor tekstu moĪe w tym samym czasie formatowaü jeden tekst i dru- kowaü inny, pod warunkiem Īe obie akcje są wykonywane przez osobne wątki. ChociaĪ Java wykorzystuje Ğrodowiska wielozadaniowe oparte na procesach, to nie umoĪliwia sterowania ich dziaáaniem. W przypadku wątków sprawy mają siĊ inaczej. Podstawową zaletą wielowątkowoĞci jest moĪliwoĞü tworzenia efektywnie dziaáających pro- gramów, poniewaĪ wielowątkowoĞü pozwala wykorzystaü okresy bezczynnoĞci pojawiające siĊ w dziaáaniu wiĊkszoĞci programów. WiĊkszoĞü urządzeĔ wejĞcia i wyjĞcia takich jak porty sieciowe, napĊdy dyskowe czy klawiatura dziaáa znacznie wolniej od procesora. Z tego powodu program czĊsto spĊdza wiele czasu na oczekiwaniu na moĪliwoĞü wysáania lub odebrania danych za poĞrednictwem urządzenia. Zastosowanie wielowątkowoĞci pozwala programowi wykonywaü w tym czasie inne zadania. Na przykáad w czasie gdy jedna czĊĞü programu wysyáa plik w Internecie, inna moĪe zajmowaü siĊ odczytem klawiatury, a jeszcze inna buforowaü kolejny blok wysyáanych danych. W ostatnich kilku latach mamy do czynienia z upowszechnieniem siĊ systemów wieloproce- sorowych i wielordzeniowych. OczywiĞcie nie wyparáy one zupeánie systemów jednoproceso- rowych. WielowątkowoĞü w Javie moĪe dziaáaü w obu typach systemów. W przypadku sys- temu jednordzeniowego wykonywane równolegle wątki wspóádzielą procesor i kaĪdy wątek otrzymuje pewien przedziaá czasu procesora. Zatem w systemie jednordzeniowym dwa lub wiĊcej wątków nie jest w rzeczywistoĞci wykonywanych równoczeĞnie, ale ich zastosowanie pozwala wykorzystaü czas bezczynnoĞci procesora. Natomiast w systemach wieloproceso- rowych bądĨ wielordzeniowych wątki rzeczywiĞcie mogą dziaáaü równolegle. W wielu przy- padkach pozwala to jeszcze bardziej poprawiü efektywnoĞü dziaáania programu i zwiĊkszyü szybkoĞü wykonywania niektórych operacji. Wątek moĪe znajdowaü siĊ w jednym z kilku stanów. MoĪe byü wykonywany. MoĪe byü gotowy do wykonywania, gdy tylko otrzyma czas procesora. Wykonanie wątku moĪe zostaü zawieszone, co oznacza, Īe wątek nie jest wykonywany przez pewien czas. Jego wykonywanie moĪe zostaü póĨniej podjĊte. Wątek moĪe zostaü zablokowany w oczekiwaniu na zwolnienie pewnego zasobu. I wreszcie wykonywanie wątku moĪe zostaü zakoĔczone, co oznacza, Īe nie moĪna juĪ go podjąü. WielowątkowoĞü wiąĪe siĊ nierozerwalnie z pojĊciem synchronizacji, która umoĪliwia skoor- dynowane dziaáanie wielu wątków. Java dysponuje kompletnym podsystemem synchronizacji. Jego podstawowe moĪliwoĞci równieĪ omówiĊ w tym rozdziale. Rozdziaä 11. i Programowanie wielowñtkowe 365 JeĞli programowaáeĞ juĪ na przykáad w systemie Windows, to byü moĪe masz pewne pojĊcie o wielowątkowoĞci. Java umoĪliwia zarządzanie wątkami za pomocą odpowiednich elementów jĊzyka, co czyni programowanie wielowątkowe szczególnie wygodnym, poniewaĪ wiele jego szczegóáów Java obsáuguje za Ciebie. Klasa Thread i interfejs Runnable WielowątkowoĞü w Javie bazuje na klasie Thread i towarzyszącym jej interfejsie Runnable, które umieszczono w pakiecie java.lang. Klasa Thread hermetyzuje wątek. JeĞli chcesz stwo- rzyü w programie nowy wątek, powinieneĞ utworzyü obiekt klasy pochodnej klasy Thread albo zaimplementowaü interfejs Runnable. Klasa Thread definiuje szereg metod pomagających zarządzaü wątkami. NajczĊĞciej uĪywane z tych metod przedstawiáem w tabeli 11.1 (przyjrzymy siĊ im bliĪej podczas ich uĪycia w przykáadach). Tabela 11.1. Wybrane metody klasy Thread Metoda final String getName( ) final int getPriority( ) final boolean isAlive( ) final void join( ) void run( ) static void sleep(long milisekund) void start( ) Znaczenie Zwraca nazwĊ wątku. Zwraca priorytet wątku. Sprawdza, czy wątek jest nadal wykonywany. Czeka na zakoĔczenie wątku. Punkt wejĞcia wątku. Zawiesza wykonywanie wątku na podaną liczbĊ milisekund. Rozpoczyna wykonywanie wątku przez wywoáanie metody run( ). Wszystkie procesy mają przynajmniej jeden wątek wykonania, zwykle nazywany wątkiem gáównym, poniewaĪ jego wykonanie rozpoczyna siĊ w momencie uruchomienia programu. MoĪemy zatem powiedzieü, Īe we wszystkich dotychczasowych przykáadach uĪywaliĞmy wątku gáównego. W wątku gáównym moĪesz tworzyü kolejne wątki programu. Tworzenie wñtku Wątek powstaje przez utworzenie obiektu typu Thread. Klasa Thread hermetyzuje obiekt, który moĪe byü wykonywany. Jak juĪ wspomniaáem, Java umoĪliwia dwa sposoby tworzenia takich obiektów:  poprzez implementacjĊ interfejsu Runnable,  poprzez tworzenie klas pochodnych klasy Thread. W wiĊkszoĞci przykáadów w tym rozdziale bĊdziemy implementowaü interfejs Runnable. Natomiast w przykáadzie 11.1 zademonstrujĊ, jak zaimplementowaü wątek, tworząc klasĊ 366 Java. Przewodnik dla poczñtkujñcych pochodną klasy Thread. ZapamiĊtaj: oba podejĞcia i tak uĪywają klasy Thread do tworzenia wątku i zarządzania nim. Jedyna róĪnica polega na sposobie, w jaki powstaje klasa reprezentu- jąca wątki. Interfejs Runnable stanowi abstrakcjĊ wykonywalnego kodu. Wątek moĪesz utworzyü na podstawie kaĪdego obiektu, który implementuje interfejs Runnable. Interfejs ten ma tylko jedną metodĊ o nazwie run() zadeklarowaną w nastĊpujący sposób: public void run() Wewnątrz metody run() umieszczasz kod wykonywany przez nowy wątek. Podobnie jak gáówny wątek programu, tak i metoda run()moĪe wywoáywaü inne metody, uĪywaü innych klas i deklarowaü zmienne. Jedyna róĪnica polega na tym, Īe metoda run() jest punktem wejĞcia do osobnego, równolegle wykonywanego wątku programu. Wykonywanie tego wątku koĔczy siĊ, gdy metoda run() zwróci sterowanie. Po utworzeniu klasy implementującej interfejs Runnable na podstawie jej obiektu tworzysz obiekt typu Thread. Klasa Thread definiuje szereg konstruktorów. Na początek bĊdziemy uĪywaü poniĪszego: Thread(Runnable obWætku) W tym przypadku parametr obWætku jest instancją klasy implementującej interfejs Runnable. Definiuje on punkt, w którym rozpocznie siĊ wykonywanie nowego wątku. Po utworzeniu nowy wątek nie bĊdzie wykonywany, dopóki nie wywoáasz jego metody start() zadeklarowanej w klasie Thread. Dziaáanie metody start() sprowadza siĊ w zasadzie do wywoáania metody run(). PoniĪej przedstawiáem deklaracjĊ metody start(): void start() Na listingu 11.1 przedstawiáem przykáad programu, który tworzy nowy wątek i rozpoczyna jego wykonywanie. Listing 11.1. UseThreads.java // Tworzy wątek, implementując interfejs Runnable. class MyThread implements Runnable { String thrdName; MyThread(String name) { thrdName = name; } Obiekty klasy MyThread mogñ byè wykonywane we wäasnych wñtkach, poniewaĔ klasa MyThread implementuje interfejs Runnable. // Punkt wejĞciowy wątku. public void run() { Tutaj rozpoczyna siö wykonywanie wñtku. System.out.println(thrdName + rozpoczyna dziađanie. ); try { for(int count=0; count 10; count++) { Thread.sleep(400); System.out.println(thrdName + jest wykonywany, wartoħè licznika: + count); } } Rozdziaä 11. i Programowanie wielowñtkowe 367 catch(InterruptedException exc) { System.out.println(thrdName + zostađ przerwany. ); } System.out.println(thrdName + koēczy dziađanie. ); } } class UseThreads { public static void main(String args[]) { System.out.println( Gđówny wætek rozpoczyna dziađanie. ); // Najpierw tworzy obiekt klasy MyThread. MyThread mt = new MyThread( Wætek potomny nr 1 ); Tworzy obiekt implementujñcy interfejs Runnable. // NastĊpnie na jego podstawie tworzy wątek. Thread newThrd = new Thread(mt); Tworzy wñtek dla tego obiektu. // Na koniec rozpoczyna wykonywanie wątku. newThrd.start(); Uruchamia wñtek. for(int i=0; i 50; i++) { System.out.print( . ); try { Thread.sleep(100); } catch(InterruptedException exc) { System.out.println( Wætek gđówny zostađ przerwany. ); } } System.out.println( Wætek gđówny koēczy dziađanie. ); } } Przyjrzyjmy siĊ bliĪej temu programowi. Najpierw klasa MyThread implementuje interfejs Runnable. Oznacza to, Īe obiekt typu MyThread moĪe zostaü przekazany konstruktorowi klasy i byü wykonywany we wáasnym wątku. Wewnątrz metody run() dziaáa pĊtla for odliczająca od 0 do 9. Zwróü uwagĊ na wywoáanie metody sleep(). Metoda sleep() powoduje zawieszenie wątku, w którym zostaáa wywoáana, na czas wyraĪony w milisekundach. Jej deklaracjĊ przedstawiáem poniĪej: static void sleep(long milisekund) throwws InterruptedException Wykonywanie wątku zostaje zawieszone na czas milisekund. Metoda sleep() mo
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Java. Przewodnik dla początkujących. Wydanie V
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ą: