Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00292 004743 14459768 na godz. na dobę w sumie
Praktyczny kurs Java. Wydanie III - książka
Praktyczny kurs Java. Wydanie III - książka
Autor: Liczba stron: 400
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-3228-2 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook, audiobook).

Uniwersalna i niezastąpiona - Java na każdą okazję

Język Java nieprzerwanie święci triumfy na salonach profesjonalnych firm, zajmujących się programowaniem. Jest wykorzystywany zarówno w prostych programach dla telefonów komórkowych, jak i w skomplikowanych aplikacjach sieciowych. Jego główne zalety to duża przenośność i świetna, przemyślana konstrukcja, która pozwala łatwo opanować zasady programowania i szybko zacząć tworzyć własne, dobrze działające programy. Java ma jeszcze jedną cechę, istotną z punktu widzenia każdej osoby zajmującej się informatyką - po prostu nie wypada jej nie znać!

Książka 'Praktyczny kurs Java. Wydanie III ' oferuje swoim czytelnikom możliwość łatwego i szybkiego zapoznania się z podstawami programowania w tym języku. Z jej pomocą w mig zainstalujesz odpowiednie środowisko programistyczne i poznasz reguły budowania aplikacji w Javie, typy danych oraz rodzaje zmiennych. Nauczysz się kontrolować przebieg wykonywania programu oraz wykorzystywać tablice. Zrozumiesz, na czym polega programowanie obiektowe i związane z nim podstawowe pojęcia, takie jak dziedziczenie i polimorfizm. Dowiesz się, jak obsługiwać i tworzyć wyjątki, jak działa system wejścia-wyjścia, co to są kontenery i typy uogólnione oraz czym różnią się aplikacje od apletów. A wszystko to w serii znakomitych, praktycznych ćwiczeń!

Zanurz się w świecie Javy!

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

Darmowy fragment publikacji:

Praktyczny kurs Java. Wydanie III Autor: Marcin Lis ISBN: 978-83-246-3228-2 Format: 158×235, stron: 400 Uniwersalna i niezastąpiona – Java na każdą okazję • Poznaj podstawy – środowisko, struktura i kompilacja programu • Dowiedz się więcej – instrukcje języka, wyjątki i programowanie obiektowe • Wykorzystaj różne możliwości – system wejścia-wyjścia, kontenery, aplikacje i aplety Język Java nieprzerwanie święci triumfy na salonach profesjonalnych firm, zajmujących się programowaniem. Jest wykorzystywany zarówno w prostych programach dla telefonów komórkowych, jak i w skomplikowanych aplikacjach sieciowych. Jego główne zalety to duża przenośność i świetna, przemyślana konstrukcja, która pozwala łatwo opanować zasady programowania i szybko zacząć tworzyć własne, dobrze działające programy. Java ma jeszcze jedną cechę, istotną z punktu widzenia każdej osoby zajmującej się informatyką – po prostu nie wypada jej nie znać! Książka „Praktyczny kurs Java. Wydanie III” oferuje swoim czytelnikom możliwość łatwego i szybkiego zapoznania się z podstawami programowania w tym języku. Z jej pomocą w mig zainstalujesz odpowiednie środowisko programistyczne i poznasz reguły budowania aplikacji w Javie, typy danych oraz rodzaje zmiennych. Nauczysz się kontrolować przebieg wykonywania programu oraz wykorzystywać tablice. Zrozumiesz, na czym polega programowanie obiektowe i związane z nim podstawowe pojęcia, takie jak dziedziczenie i polimorfizm. Dowiesz się, jak obsługiwać i tworzyć wyjątki, jak działa system wejścia-wyjścia, co to są kontenery i typy uogólnione oraz czym różnią się aplikacje od apletów. A wszystko to w serii znakomitych, praktycznych ćwiczeń! • Krótka historia Javy, jej narzędzia i wersje • Instalacja JDK i podstawy programowania • Zmienne, instrukcje sterujące i tablice • Dziedziczenie, polimorfizm, interfejsy i klasy wewnętrzne • Wyjątki • System wejścia-wyjścia • Kontenery i typy uogólnione • Aplikacje i aplety Zanurz się w świecie Javy! Idź do • Spis treści • Przykładowy rozdział • Skorowidz Katalog książek • Katalog online • Zamów drukowany katalog Twój koszyk • Dodaj do koszyka Cennik i informacje • Zamów informacje o nowościach • Zamów cennik Czytelnia • Fragmenty książek online Kontakt Helion SA ul. Kościuszki 1c 44-100 Gliwice tel. 32 230 98 63 e-mail: helion@helion.pl © Helion 1991–2011 Spis treĈci Wstöp .............................................................................................. 5 Rozdziaä 1. Podstawy ......................................................................................... 9 Instalacja JDK .................................................................................................................. 9 Instalacja w systemie Windows ................................................................................ 10 Instalacja w systemie Linux ..................................................................................... 10 Przygotowanie do pracy z JDK ................................................................................ 11 Podstawy programowania ............................................................................................... 13 Lekcja 1. Struktura programu, kompilacja i wykonanie ........................................... 13 Lekcja 2. Podstawy obiektowoĞci i typy danych ...................................................... 15 Lekcja 3. Komentarze ............................................................................................... 18 Rozdziaä 2. Instrukcje jözyka ............................................................................ 21 Zmienne .......................................................................................................................... 21 Lekcja 4. Deklaracje i przypisania ........................................................................... 22 Lekcja 5. Wyprowadzanie danych na ekran ............................................................. 25 Lekcja 6. Operacje na zmiennych ............................................................................. 30 Instrukcje sterujące ......................................................................................................... 43 Lekcja 7. Instrukcja warunkowa if...else .................................................................. 43 Lekcja 8. Instrukcja switch i operator warunkowy ................................................... 49 Lekcja 9. PĊtle .......................................................................................................... 54 Lekcja 10. Instrukcje break i continue ...................................................................... 62 Tablice ............................................................................................................................ 69 Lekcja 11. Podstawowe operacje na tablicach .......................................................... 69 Lekcja 12. Tablice wielowymiarowe ........................................................................ 74 Rozdziaä 3. Programowanie obiektowe .............................................................. 85 Podstawy ........................................................................................................................ 85 Lekcja 13. Klasy, pola i metody ............................................................................... 86 Lekcja 14. Argumenty i przeciąĪanie metod ............................................................ 94 Lekcja 15. Konstruktory ......................................................................................... 104 Dziedziczenie ............................................................................................................... 115 Lekcja 16. Klasy potomne ...................................................................................... 116 Lekcja 17. Specyfikatory dostĊpu i pakiety ............................................................ 123 Lekcja 18. Przesáanianie metod i skáadowe statyczne ............................................ 137 Lekcja 19. Klasy i skáadowe finalne ....................................................................... 149 4 Praktyczny kurs Java Rozdziaä 4. Wyjñtki ........................................................................................ 157 Lekcja 20. Blok try...catch ..................................................................................... 157 Lekcja 21. Wyjątki to obiekty ................................................................................ 165 Lekcja 22. Wáasne wyjątki ..................................................................................... 173 Rozdziaä 5. Programowanie obiektowe II ......................................................... 185 Polimorfizm .................................................................................................................. 185 Lekcja 23. Konwersje typów i rzutowanie obiektów .............................................. 185 Lekcja 24. PóĨne wiązanie i wywoáywanie metod klas pochodnych ..................... 194 Lekcja 25. Konstruktory oraz klasy abstrakcyjne ................................................... 202 Interfejsy ....................................................................................................................... 211 Lekcja 26. Tworzenie interfejsów .......................................................................... 211 Lekcja 27. Wiele interfejsów .................................................................................. 217 Klasy wewnĊtrzne ........................................................................................................ 225 Lekcja 28. Klasa w klasie ....................................................................................... 225 Lekcja 29. Rodzaje klas wewnĊtrznych i dziedziczenie ......................................... 233 Lekcja 30. Klasy anonimowe i zagnieĪdĪone ......................................................... 241 Rozdziaä 6. System wejĈcia-wyjĈcia ................................................................ 249 Lekcja 31. Standardowe wejĞcie ............................................................................ 249 Lekcja 32. Standardowe wejĞcie i wyjĞcie ............................................................. 259 Lekcja 33. System plików ...................................................................................... 274 Lekcja 34. Operacje na plikach .............................................................................. 285 Rozdziaä 7. Kontenery i typy uogólnione .......................................................... 301 Lekcja 35. Kontenery ............................................................................................. 301 Lekcja 36. Typy uogólnione ................................................................................... 314 Rozdziaä 8. Aplikacje i aplety ......................................................................... 327 Aplety ........................................................................................................................... 327 Lekcja 37. Podstawy apletów ................................................................................. 327 Lekcja 38. Kroje pisma (fonty) i kolory ................................................................. 333 Lekcja 39. Grafika .................................................................................................. 342 Lekcja 40. DĨwiĊki i obsáuga myszy ...................................................................... 350 Aplikacje ...................................................................................................................... 360 Lekcja 41. Tworzenie aplikacji .............................................................................. 360 Lekcja 42. Komponenty ......................................................................................... 376 Skorowidz ..................................................................................... 391 Rozdziaä 6. System wejĈcia-wyjĈcia Do pisania aplikacji w Javie niezbĊdna jest znajomoĞü przynajmniej podstaw systemu wejĞcia-wyjĞcia. Tej tematyce jest poĞwiĊcony wáaĞnie rozdziaá 6. W Javie takie opera- cje są wykonywane za pomocą strumieni. StrumieĔ to abstrakcyjny ciąg danych, który dziaáa — mówiąc w uproszczeniu — w taki sposób, Īe dane wprowadzone w jednym jego koĔcu pojawiają siĊ na drugim koĔcu. Strumienie dzielą siĊ na wejĞciowe i wyj- Ğciowe. Strumienie wyjĞciowe mają początek w aplikacji i koniec w innym urządzeniu, np. na ekranie czy w pliku, umoĪliwiają zatem wyprowadzanie danych z programu. Przy- káadowo standardowy strumieĔ wyjĞciowy jest reprezentowany przez obiekt System.out, a wykonanie metody println tego obiektu powoduje, Īe standardowo dane zostają wysáane na ekran. Strumienie wejĞciowe dziaáają odwrotnie: ich początek znajduje siĊ poza aplikacją (moĪe byü to np. klawiatura albo plik dyskowy), a koniec w aplikacji; umoĪliwiają zatem wprowadzanie danych. Co wiĊcej, strumienie umoĪliwiają teĪ komu- nikacjĊ miĊdzy obiektami w obrĊbie jednej aplikacji, w tym rozdziale jednak zostanie omówiona jedynie komunikacja aplikacji ze Ğwiatem zewnĊtrznym. Lekcja 31. Standardowe wejĈcie Podstawowe operacje wyjĞciowe, czyli wyĞwietlanie informacji na ekranie konsoli, pojawiáy siĊ juĪ wielokrotnie; dokáadniej zostaną opisane w ramach kolejnej lekcji. Omówienie systemu wejĞcia-wyjĞcia rozpocznie siĊ od wprowadzenia danych i stan- dardowego strumienia wejĞciowego reprezentowanego przez obiekt System.in. Tej tematyce zostanie poĞwiĊcona caáa bieĪąca lekcja. Nauczysz siĊ odczytywaü dane wpro- wadzane przez uĪytkownika z klawiatury. Standardowy strumieþ wejĈciowy Standardowy strumieĔ wejĞciowy jest reprezentowany przez obiekt System.in, czyli obiekt in zawarty w klasie System. Jest to obiekt typu InputStream, klasy reprezentują- cej strumieĔ wejĞciowy. Metody udostĊpniane przez tĊ klasĊ są zebrane w tabeli 6.1. Jak widaü, nie jest to imponujący zestaw, niemniej jest to podstawowa klasa operująca na strumieniu wejĞciowym. 250 Praktyczny kurs Java Tabela 6.1. Metody udostĊpniane przez klasĊ InputStream Deklaracja metody int available() Opis Zwraca przewidywalną liczbĊ bajtów, które mogą byü pobrane ze strumienia przy najbliĪszym odczycie Zamyka strumieĔ i zwalnia związane z nim zasoby void close() void mark(int readlimit) Zaznacza bieĪącą pozycjĊ w strumieniu boolean markSupported() abstract int read() int read(byte[] b) Sprawdza, czy strumieĔ moĪe obsáugiwaü metody mark i reset Odczytuje kolejny bajt ze strumienia Odczytuje ze strumienia liczbĊ bajtów nie wiĊkszą niĪ rozmiar tablicy b. Zwraca faktycznie odczytaną liczbĊ bajtów Odczytuje ze strumienia liczbĊ bajtów nie wiĊkszą niĪ wskazywana przez len i zapisuje je w tablicy b, począwszy od komórki wskazywanej przez off. Zwraca faktycznie przeczytaną liczbĊ bajtów Wraca do pozycji strumienia wskazywanej przez wywoáanie metody mark Pomija w strumieniu liczbĊ bajtów wskazywanych przez n. Zwraca faktycznie pominiĊtą liczbĊ bajtów int read(byte[] b, int off, int len) void reset() long skip(long n) Widaü wyraĨnie, Īe odczyt bajtów ze strumienia moĪna przeprowadziü za pomocą jednej z metod o nazwie read. Przyjrzyjmy siĊ metodzie odczytującej tylko jeden bajt. Mimo Īe odczytuje ona bajt, zwraca wartoĞü typu int. Jest tak dlatego, Īe zwracana wartoĞü zawsze zawiera siĊ w przedziale 0 – 255 (to tyle, ile moĪe przyjmowaü jeden bajt). Tymczasem zmienna typu byte reprezentuje wartoĞci „ze znakiem” w zakresie od –128 do +1271. Spróbuj zatem napisaü prosty program, który odczyta wprowadzony z klawiatury znak, a nastĊpnie wyĞwietli ten znak oraz jego kod ASCII na ekranie. Kod realizujący przedstawione zadanie jest widoczny na listingu 6.1. Listing 6.1. import java.io.*; public class Main { ..public static void main(String args[]) { System.out.print( Wprowadļ dowolny znak z klawiatury: ); try{ char c = (char) System.in.read(); System.out.print( Wprowadzony znak to: ); System.out.println(c); System.out.print( Jego kod to: ); System.out.println((int) c); } catch(IOException e){ System.out.println( Bđæd podczas odczytu strumienia. ); } ..} } 1 OczywiĞcie reprezentowanie zakresu od 0 do 255 byáoby równieĪ moĪliwe za pomocą typów short i long. Rozdziaä 6. i System wejĈcia-wyjĈcia 251 Pierwszym krokiem jest zaimportowanie pakietu java.io (por. lekcja 17.), znajduje siĊ w nim bowiem definicja klasy wyjątku IOException, który musisz przechwyciü. W metodzie main za pomocą metody System.out.println wyĞwietlasz tekst z proĞbą o wprowadzenie dowolnego znaku z klawiatury, a nastĊpnie wykonujesz instrukcjĊ: char c = (char) System.in.read(); Wywoáujesz zatem metodĊ read obiektu in zawartego w klasie System2. Obiekt ten jest klasy InputStream (typem obiektu jest InputStream) i reprezentuje standardowy stru- mieĔ wejĞciowy. Standardowo jest on powiązany z klawiaturą, zatem z tego strumienia bĊdą odczytywane dane wprowadzane przez uĪytkownika z klawiatury. Metoda read zwraca wartoĞü typu int, dokonujesz zatem konwersji na typ char, tak aby wyĞwietliü na ekranie wprowadzony znak, i przypisujesz go zmiennej c. NastĊpnie wyĞwietlasz zawartoĞü tej zmiennej za pomocą instrukcji: System.out.println(c); Aby wyĞwietliü kod znaku, musisz ponownie dokonaü konwersji. Zmienną c typu char konwertujesz zatem na typ byte, tak aby metoda println potraktowaáa ją jako liczbĊ, a nie jako znak. PoniewaĪ metoda read moĪe spowodowaü powstanie wyjątku IOException, wszystkie instrukcje zostaáy ujĊte w blok try, który zapobiegnie niekon- trolowanemu zakoĔczeniu programu (por. lekcje z rozdziaáu 4.). Przykáadowy efekt dziaáania programu z listingu 6.1 jest widoczny na rysunku 6.1. Rysunek 6.1. Przykáadowy efekt dziaáania programu z listingu 6.1 Trzeba zwróciü uwagĊ, Īe w ten sposób tak naprawdĊ odczytywany jest ze strumienia nie jeden znak, ale jeden bajt. A te pojĊcia nie są toĪsame. Jeden znak moĪe przyjmo- waü w zaleĪnoĞci od standardu kodowania od jednego do kilku bajtów. Wczytywanie tekstu Wiesz juĪ, jak odczytaü jeden bajt, co jednak zrobiü, aby wprowadziü caáą liniĊ tekstu? PrzecieĪ taka sytuacja jest o wiele czĊstsza. MoĪna oczywiĞcie odczytywaü pojedyn- cze znaki w pĊtli tak dáugo, aĪ zostanie osiągniĊty znak koĔca linii, oraz poáączyü je w obiekt typu String. Najlepiej byáoby wrĊcz wyprowadziü z klasy InputStream klasĊ pochodną, która zawieraáaby metodĊ np. o nazwie readLine, wykonującą taką czyn- noĞü. Trzeba by przy tym pamiĊtaü o odpowiedniej obsáudze standardów kodowania znaków. Na szczĊĞcie w JDK zostaá zdefiniowany caáy zestaw klas operujących na strumieniach wejĞciowych. Zamiast wiĊc powtarzaü coĞ, co zostaáo juĪ zrobione, naj- lepiej po prostu z nich skorzystaü. 2 Obiekt in jest finalnym i statycznym polem klasy System. 252 Praktyczny kurs Java Zadanie to bĊdzie wymagaáo skorzystania z dwóch klas poĞredniczących. Klasą udo- stĊpniającą metodĊ readLine, która jest w stanie prawidáowo zinterpretowaü znaki przychodzące ze strumienia, jest BufferedReader. Aby jednak moĪna byáo utworzyü obiekt takiej klasy, musi powstaü obiekt klasy Reader lub klasy od niej pochodnej — w tym przypadku najodpowiedniejszy bĊdzie InputStreamReader. PoniewaĪ nie ma takiego obiektu w aplikacji (do dyspozycji masz jedynie obiekt System.in typu Input ´Stream), naleĪy go utworzyü, wywoáując odpowiedni konstruktor. BĊdzie to obiekt (strumieĔ) poĞredniczący w wymianie danych. Do jego utworzenia potrzeba z kolei obiektu klasy InputStream, a tym przecieĪ dysponujesz. Dlatego teĪ kod programu, który odczytuje liniĊ tekstu ze standardowego wejĞcia, bĊdzie wyglądaü tak, jak zostaáo to przedstawione na listingu 6.2. Listing 6.2. import java.io.*; public class Main { public static void main(String args[]) { BufferedReader brIn = new BufferedReader( new InputStreamReader(System.in) ); System.out.println( Wprowadļ liniú tekstu zakoēczonæ znakiem Enter: ); try{ String line = brIn.readLine(); System.out.print( Wprowadzona linia to: + line); } catch(IOException e){ System.out.println( Bđæd podczas odczytu strumienia. ); } } } Pierwszym zadaniem jest utworzenie obiektu brIn klasy BufferedReader. Mamy tu do czynienia ze záoĪoną instrukcją, która najpierw tworzy obiekt typu InputStreamReader, wykorzystując obiekt System.in, i dopiero ten obiekt przekazuje konstruktorowi klasy BufferedReader. Zatem konstrukcjĊ: BufferedReader brIn = new BufferedReader( new InputStreamReader(System.in) ); moĪna równieĪ rozbiü na dwie fazy: InputStreamReader isr = new InputStreamReader(System.in); BufferedReader brIn = new BufferedReader(isr); Znaczenie bĊdzie takie samo, jednak w drugim przypadku zostaje utworzona zupeánie niepotrzebnie dodatkowa zmienna isr typu InputStreamReader. Który ze sposobów jest czytelniejszy i zostanie zastosowany, zaleĪy jednak od indywidualnych preferencji programisty. Z reguáy stosuje siĊ sposób pierwszy. Kiedy obiekt klasy BufferedReader jest juĪ utworzony, moĪna wykorzystaü metodĊ readLine, która zwróci w postaci obiektu typu String (klasa String reprezentuje ciągi Rozdziaä 6. i System wejĈcia-wyjĈcia 253 znaków) liniĊ tekstu wprowadzoną przez uĪytkownika. Linia tekstu jest rozumiana jako ciąg znaków wprowadzony aĪ do naciĞniĊcia klawisza Enter (dokáadniej: aĪ do osią- gniĊcia znaku koĔca wiersza w strumieniu). Wynika z tego, Īe instrukcja: String line = brIn.readLine(); utworzy zmienną line typu String i przypisze jej obiekt zwrócony przez metodĊ readLine obiektu brIn. Dziaáanie programu bĊdzie zatem nastĊpujące: po uruchomieniu zostanie wyĞwietlona proĞba o wprowadzenie linii tekstu, nastĊpnie linia ta zostanie odczytana i przypisana zmiennej line, a potem zawartoĞü tej zmiennej zostanie wyĞwietlona na ekranie. Przykáad wykonania pokazano na rysunku 6.2. Rysunek 6.2. Wczytanie linii tekstu za pomocą obiektu klasy BufferedReader Skoro potrafisz juĪ wczytaü wiersz tekstu z klawiatury, spróbuj napisaü program, któ- rego zadaniem bĊdzie wczytywanie kolejnych linii ze standardowego wejĞcia tak dáugo, aĪ zostanie odczytany ciąg znaków quit. Zadanie wydaje siĊ banalne, wystarczy prze- cieĪ do kodu z listingu 6.2 dodaü pĊtlĊ while, która bĊdzie sprawdzaáa, czy zmienna line zawiera napis quit. W pierwszym odruchu napiszesz zapewne pĊtlĊ o nastĊpującej postaci (przy zaáoĪeniu, Īe wczeĞniej zostaá prawidáowo zainicjowany obiekt brIn): String line = ; while(line != quit ){ line = brIn.readLine(); System.out.println( Wprowadzona linia to: + line); } System.out.println( Koniec wczytywania danych. ); Warto przeanalizowaü ten przykáad. Na początku deklarujesz zmienną line i przypi- sujesz jej pusty ciąg znaków. W pĊtli while sprawdzasz warunek, czy zmienna line jest róĪna od ciągu znaków quit — jeĞli tak, to pĊtla jest kontynuowana, a jeĞli nie, to koĔczy dziaáanie. Zatem znaczenie jest nastĊpujące: dopóki line jest róĪne od quit, wykonuj instrukcje z wnĊtrza pĊtli. Wewnątrz pĊtli przypisujesz natomiast zmiennej line wiersz tekstu odczytany ze standardowego strumienia wejĞciowego oraz wyĞwie- tlasz go na ekranie. Wszystko to wygląda bardzo poprawnie, ma tylko jedną wadĊ — nie zadziaáa zgodnie z zaáoĪeniami. Spróbuj uruchomiü program z listingu 6.3. Wpisz kilka linii tekstu, a nastĊpnie ciąg znaków quit. Teoretycznie program powinien zakoĔczyü dziaáanie, tymczasem dziaáa nadal, co jest widoczne na rysunku 6.3. Listing 6.3. import java.io.*; public class Main { public static void main(String args[]) { BufferedReader brIn = new BufferedReader( 254 Rysunek 6.3. Báąd w pĊtli while uniemoĪliwia zakoĔczenie programu Praktyczny kurs Java new InputStreamReader(System.in) ); System.out.println( Wprowadzaj linie tekstu. Aby zakoēczyè, wpisz quit. ); String line = ; try{ while(line != quit ){ line = brIn.readLine(); System.out.println( Wprowadzona linia to: + line); } System.out.println( Koniec wczytywania danych. ); } catch(IOException e){ System.out.println( Bđæd podczas odczytu strumienia. ); } } } Co siĊ zatem dzieje, gdzie jest báąd? Twoje podejrzenie powinno najpierw paĞü na warunek zakoĔczenia pĊtli while. On faktycznie jest nieprawidáowy, choü wydaje siĊ, Īe instrukcja ta jest poprawna. Zwróü uwagĊ na to, co tak naprawdĊ jest w tym warunku porównywane. Miaá byü porównany ciąg znaków zapisany w zmiennej line z ciągiem znaków quit. Tymczasem po umieszczeniu w kodzie sekwencji quit , powstaá nie- nazwany obiekt klasy String faktycznie zawierający ciąg znaków quit, a w miejsce napisu quit zostaáa wstawiona referencja do tego obiektu. Jak wiesz z wczeĞniejszych lekcji (por. lekcja 13.), zmienna line jest takĪe referencją do obiektu klasy String. Sama zatem instrukcja porównania line != quit porównuje ze sobą dwie REFERENCJE, które muszą byü róĪne. Nie dochodzi tu zatem do porównania zawartoĞci obiektów. Dlatego program nie moĪe dziaáaü poprawnie i wpada w nieskoĔczoną pĊtlĊ (aby go zakoĔczyü, trzeba wcisnąü na klawiaturze kombinacjĊ klawiszy Ctrl+C). Koniecznie naleĪy wiĊc zapamiĊtaü, Īe do porównywania obiektów nie uĪywa siĊ operatorów porównywania! Zamiast tego naleĪy skorzystaü z metody equals. Jest ona zadeklarowana w klasie Object i w związku z tym dziedziczona przez wszystkie klasy. Warto pamiĊtaü o tym podczas tworzenia wáasnych klas, by w razie potrzeby dopisaü wáasną wersjĊ tej metody. Jak zastosowaü tĊ metodĊ w praktyce? OtóĪ zwraca ona wartoĞü true, kiedy obiekty są takie same (czyli ich zawartoĞü jest taka sama), lub false, kiedy obiekty są róĪne. W przypadku obiektów typu String wartoĞü true bĊdzie zwrócona, kiedy ciąg znaków zapisany w jednym z nich jest taki sam jak ciąg znaków zapisany w drugim. JeĞli np. istnieje zmienna zadeklarowana jako: String napis1 = test ; Rozdziaä 6. i System wejĈcia-wyjĈcia 255 to wynikiem operacji: napis1.equals( test ); bĊdzie wartoĞü true, a wynikiem operacji: napis1.equals( java ); bĊdzie wartoĞü false. Powróümy teraz do pĊtli while. Jako Īe znasz juĪ wáaĞciwoĞci metody equals, w pierw- szej chwili na pewno zechcesz napisaü warunek: while(!line.equals( quit )){ /*instrukcje pĊtli while*/ } JeĞli wprowadzisz go do kodu z listingu 6.3, zacznie on poprawnie reagowaü na pole- cenie quit — bĊdzie siĊ wiĊc wydawaü, Īe program nareszcie dziaáa zgodnie z zaáo- Īeniami. W zasadzie moĪna by siĊ zgodziü z tym stwierdzeniem, gdyĪ faktycznie dziaáa zgodnie z zaáoĪeniami, tylko Īe jednoczeĞnie zawiera kolejny báąd, tym razem duĪo trudniejszy do odkrycia. Ujawni siĊ on dopiero przy próbie przerwania pracy aplikacji. Uruchom program, wpisz testową liniĊ tekstu oraz przerwij jego dziaáanie (w wiĊkszo- Ğci systemów naleĪy wcisnąü kombinacjĊ klawiszy Ctrl+C). Efekt jest widoczny na rysunku 6.4. Zapewne zaskoczyáo CiĊ powstanie wyjątku NullPointerException… Rysunek 6.4. Ukryty báąd w programie spowodowaá wygenerowanie wyjątku Na przyczynĊ powstania tego báĊdu naprowadza linia tekstu poprzedzająca komunikat maszyny wirtualnej, mianowicie: Wprowadzona linia to: null. Oznacza to bowiem (spójrz na kod), Īe metoda readLine obiektu brIn zwróciáa — zamiast ciągu znaków — wartoĞü null. Jest to standardowe dziaáanie, metoda ta zwraca wartoĞü null, kiedy zosta- nie osiągniĊty koniec strumienia, czyli kiedy nie ma w nim juĪ Īadnych danych do odczytania. Co siĊ dzieje dalej? OtóĪ wartoĞü null jest przypisywana zmiennej line, a potem w warunku pĊtli while nastĊpuje próba wywoáania metody equals obiektu wskazywanego przez line. Tymczasem line ma wartoĞü null i nie wskazuje na Īaden obiekt. W takiej sytuacji musi zostaü wygenerowany wyjątek NullPointerException. Jak temu zapobiec? MoĪliwoĞci masz dwie: albo dodasz w pĊtli warunek sprawdzający, czy line jest równe null, a jeĞli tak, to przerwiesz pĊtlĊ np. instrukcją break; albo teĪ zmodyfikujesz sam warunek pĊtli. Ta druga moĪliwoĞü jest lepsza, gdyĪ nie powoduje wykonywania dodatkowego kodu, a jednoczeĞnie otrzymasz ciekawą konstrukcjĊ. Poprawiony warunek powinien bowiem wyglądaü nastĊpująco: while(! quit .equals(line)){ /*instrukcje pĊtli while*/ } 256 Praktyczny kurs Java Początkowo tego typu zapis budzi zdziwienie: jak moĪna wywoáywaü jakąkolwiek metodĊ na rzecz ciągu znaków? Przypomnij sobie jednak stwierdzenie, które pojawiáo siĊ kilka akapitów wyĪej, otóĪ literaá3 quit w rzeczywistoĞci powoduje powstanie obiektu klasy String i podstawianie w jego (literaáu) miejsce referencji do tego obiektu. Skoro tak, moĪesz wywoáaü metodĊ equals. ZauwaĪ, Īe wáaĞnie dziĊki takiej konstruk- cji unikasz wyjątku NullPointerException, gdyĪ nawet jeĞli line bĊdzie miaáo wartoĞü null, to metoda equals po prostu zwróci wartoĞü false, null bowiem na pewno jest róĪne od ciągu znaków quit. Ostatecznie peány prawidáowy kod bĊdzie miaá postaü przedstawioną na listingu 6.4. Przykáad dziaáania tego kodu zostaá z kolei zaprezento- wany na rysunku 6.5. Listing 6.4. import java.io.*; public class Main { public static void main(String args[]) { BufferedReader brIn = new BufferedReader( new InputStreamReader(System.in) ); System.out.println( Wprowadzaj linie tekstu. Aby zakoēczyè, wpisz quit. ); String line = ; try{ while(! quit .equals(line)){ line = brIn.readLine(); System.out.println( Wprowadzona linia to: + line); } System.out.println( Koniec wczytywania danych. ); } catch(IOException e){ System.out.println( Bđæd podczas odczytu strumienia. ); } } } Rysunek 6.5. Wprowadzanie w pĊtli kolejnych linii tekstu Wprowadzanie liczb Potrafisz juĪ odczytywaü w aplikacji wiersze tekstu wprowadzane z klawiatury, równie waĪną umiejĊtnoĞcią jest wprowadzanie liczb. Jak to zrobiü? Trzeba sobie uzmysáowiü, Īe z klawiatury zawsze wprowadzany jest tekst. JeĞli próbujesz wprowadziü do aplika- 3 Czyli inaczej staáa znakowa (napisowa), staáy ciąg znaków umieszczony w kodzie programu. Rozdziaä 6. i System wejĈcia-wyjĈcia 257 cji wartoĞü 123, to w rzeczywistoĞci wprowadzisz trzy znaki, 1 , 2 i 3 o kodach ASCII 61, 62, 63. Mogą one zostaü przedstawione w postaci ciągu 123 , ale to dopiero aplikacja musi przetworzyü ten ciąg na wartoĞü 123. Takiej konwersji w przypadku wartoĞci caákowitej moĪna dokonaü np. za pomocą metody parseInt z klasy Integer. Jest to metoda statyczna, moĪesz ją wiĊc wywoáaü, nie tworząc obiektu klasy Integer4. Przykáadowe wywoáanie moĪe wyglądaü nastĊpująco: int liczba = Integer.parseInt(ciæg_znaków); Zmiennej liczba zostanie przypisana wartoĞü typu int zawarta w ciągu znaków ciæg_ ´znaków. Gdyby ciąg przekazany jako argument metody parseInt nie zawieraá popraw- nej wartoĞci caákowitej, zostaáby wygenerowany wyjątek NumberFormatException. Aby zatem wprowadziü do aplikacji wartoĞü caákowitą, moĪna odczytaü wiersz tekstu, korzy- stając z metody readLine, a nastĊpnie wywoáaü metodĊ parseInt. Ten wáaĞnie sposób zostaá wykorzystany w programie z listingu 6.5. Zadaniem tego programu jest wczy- tanie liczby caákowitej oraz wyĞwietlenie wyniku mnoĪenia tej liczby przez wartoĞü 2. Listing 6.5. import java.io.*; public class Main { public static void main(String args[]) { BufferedReader brIn = new BufferedReader( new InputStreamReader(System.in) ); System.out.print( Wprowadļ liczbú cađkowitæ: ); String line = null; try{ line = brIn.readLine(); } catch(IOException e){ System.out.println( Bđæd podczas odczytu strumienia. ); return; } int liczba; try{ liczba = Integer.parseInt(line); } catch(NumberFormatException e){ System.out.print( Podana wartoħè nie jest liczbæ cađkowitæ. ); return; } System.out.print(liczba + * 2 = + liczba * 2); } } 4 Jak widaü, metody statyczne poznane w ramach lekcji 18. przydają siĊ w praktyce. 258 Praktyczny kurs Java Kod zaczynasz od utworzenia obiektu brIn klasy BufferedReader powiązanego poprzez obiekt poĞredniczący klasy InputStreamReader ze standardowym strumieniem wej- Ğciowym. Stosujesz technikĊ opisaną przy omawianiu przykáadu z listingu 6.2. NastĊp- nie wyĞwietlasz proĞbĊ o wprowadzenie liczby caákowitej oraz odczytujesz wiersz tekstu za pomocą metody readLine obiektu brIn. OczywiĞcie pamiĊtasz o przechwy- ceniu ewentualnego wyjątku IOException. W przypadku wystąpienia takiego wyjątku wyĞwietlasz stosowną informacjĊ na ekranie oraz koĔczysz wykonywanie programu. ZauwaĪ, Īe wykorzystujesz w tym celu instrukcjĊ return bez Īadnych parametrów, co oznacza wyjĞcie z funkcji main, a tym samym zakoĔczenie dziaáania aplikacji. JeĞli odczyt wiersza tekstu siĊ powiedzie, zostanie on zapisany w zmiennej line. Dekla- rujesz wiĊc dalej zmienną liczba typu int oraz przypisujesz jej wynik dziaáania metody parseInt z klasy Integer. Metodzie przekazujesz ciąg znaków zapisany w zmiennej line. JeĞli wprowadzony przez uĪytkownika ciąg znaków nie reprezentuje poprawnej wartoĞci liczbowej, wygenerowany zostaje wyjątek NumberFormatException. W takim wypadku wyĞwietlasz komunikat o tym fakcie oraz koĔczysz dziaáanie funkcji main, a tym samym programu, wywoáując instrukcjĊ return. JeĞli jednak konwersja tekstu na liczbĊ powiedzie siĊ, odpowiednia wartoĞü zostanie zapisana w zmiennej liczba, moĪesz zatem wykonaü mnoĪenie liczba * 2 i wyĞwietliü wartoĞü wynikającą z tego mnoĪenia na ekranie. Przykáadowy wynik dziaáania programu jest widoczny na rysunku 6.6. Rysunek 6.6. Przykáadowy wynik dziaáania programu z listingu 6.5 Gdyby miaáa byü wczytana liczba zmiennoprzecinkowa, naleĪaáoby do konwersji zasto- sowaü metodĊ parseDouble klasy Double lub parseFloat klasy Float, co jest doskona- áym üwiczeniem do samodzielnego wykonania. çwiczenia do samodzielnego wykonania çwiczenie 31.1. Napisz klasĊ Main, która bĊdzie zawieraáa metodĊ readLine. Zadaniem tej metody bĊdzie zwrócenie wprowadzonej przez uĪytkownika linii tekstu. Nie uĪywaj do odczytu danych innych metod niĪ System.in.read(). Przetestuj dziaáanie wáasnej metody readLine. çwiczenie 31.2. Zmodyfikuj kod z listingu 6.3 tak, aby warunek pĊtli while miaá postaü while(!line. ´equals( quit )), ale aby nie wystĊpowaá báąd NullPointerException, kiedy osiągniĊty zostanie koniec strumienia (np. po wciĞniĊciu kombinacji klawiszy Ctrl+C). çwiczenie 31.3. Napisz program (analogiczny do przedstawionego na listingu 6.5), który bĊdzie umoĪ- liwiaá wprowadzenie liczby zmiennoprzecinkowej. Skorowidz --, 31, 32, 33 !, 39 !=, 41 , 38 , 39 ., 88, 90 /* */, 19 //, 20 ? :, 53 [], 70 ^, 38 |, 38 ||, 39 ~, 38 ++, 31, 32 , 41 , 38 =, 41 applet , 329 object , 329 param , 332 ==, 41 , 41 =, 41 , 38 , 38 A abstract, 203 accept(), 280 access modifier, 123 ActionEvent, 369 ActionListener, 367, 370, 379, 380, 381, 389 actionPerformed(), 367, 368, 371, 380, 381, 389 add(), 307, 308 addActionListener(), 353, 354, 368 addDocumentListener(), 382 addItem(), 387 addKeyListener(), 376 addMouseListener(), 353, 359, 361, 376 addMouseMotionListener(), 356, 361, 376 addSeparator(), 374 addWindowListener(), 361, 362, 364 AIFF, 357 AND, 38, 39 aplety, 327 Aplet, 333 czcionki, 334 dĨwiĊki, 350, 357 fonty, 333 getParameter(), 333 grafika, 342 init(), 331, 333 kolory, 338 konstrukcja apletu, 331 koĔczenie dziaáania, 331 kroje pisma, 333, 334 obsáuga myszy, 350 obsáuga zdarzeĔ, 353 odczytywanie wartoĞci parametrów, 333 odĞwieĪanie ekranu, 350 okna, 360 parametry, 332 rysowanie, 328, 329 start(), 331 stop(), 331 styl czcionki, 335 metody, 307 ASCII, 250 AU, 357 AudioClip, 358 available(), 250 B b-code, 14 biblioteki, 130 bity, 38 testowanie, 330 tworzenie, 328 umieszczanie na stronie, 329 uruchamianie, 331 wyĞwietlanie tekstu, 335 zdarzenia, 350 aplikacje, 327, 360 JFrame, 360 komponenty, 376 menu, 365 menu kontekstowe, 373 okna, 360 tworzenie, 360 append(), 270 applet, 327 Applet, 328, 333 Applet Viewer, 330 application, 327 argumenty, 94 argumenty finalne, 154 konstruktory, 105 obiekt jako argument, 96 ArithmeticException, 165, 167, 168 ArrayIndexOutOfBoundsExcept ion, 157, 161, 166, 302, 303 ArrayList, 306, 308, 310 392 Praktyczny kurs Java b-kod, 14 blok try...catch, 157 zagnieĪdĪanie bloków, 171 báĊdy, 157 dzielenie przez zero, 166 boolean, 18 break, 50, 52, 62, 255 etykiety, 66 BufferedInputStream, 295, 299, 300 BufferedOutputStream, 299, 300 BufferedReader, 252, 260, 290, 295, 296, 308 buforowanie, 293 byte, 17 byte-code, 14 C canExecute(), 275 canRead(), 275 canWrite(), 275 case, 50, 52 catch, 157, 162 change code page, 28 changedUpdate(), 382 char, 18 chcp, 28 checkbox menu, 371 CheckBoxMenu, 371 checkError(), 270 chmod, 11 chronione skáadowe, 126 ciągi znaków, 26 class, 86 ClassCastException, 315, 319 CLASSPATH, 132 clear(), 307 clearError(), 270 clearRect(), 328, 338 close(), 250, 270, 286 Color, 333, 338, 344 compareTo(), 275 Component, 376 Console, 259, 267 console(), 267 contains(), 307, 376 continue, 62, 64 etykiety, 66, 67 CP1250, 272 createNewFile(), 275, 281, 282 createTempFile(), 275 czcionki, 28, 334 czcionki systemowe, 334 czcionki wbudowane, 334 czyszczenie obszaru okna apletu, 328 D Dąb, 5 default, 50 deklaracja interfejsy, 211 klasy, 86 klasy abstrakcyjne, 203 klasy anonimowe, 244 klasy finalne, 149 klasy pakietowe, 134 klasy publiczne, 134 klasy wewnĊtrzne, 225 konstruktory, 104 metody, 89 metody statyczne, 144 tablice, 70 tablice nieregularne, 79 typy uogólnione, 319 wiele zmiennych, 23 zmienne, 22 dekrementacja, 31, 32, 33 Delete, 284 delete(), 275, 283, 284 deleteOnExit(), 275 destruktory, 112 Dialog, 335 Dimension, 328 dispose(), 363 DivideByZeroException, 179 do...while, 59 DocumentListener, 382 doáączanie pakietów, 131 domyĞlne wartoĞci dla poszczególnych typów danych, 93 dostĊp chroniony, 126 dostĊp do klasy zewnĊtrznej, 231 dostĊp do obiektu klasy wewnĊtrznej, 234 dostĊp prywatny, 124 dostĊp publiczny, 123 double, 18 Double, 258 drawImage(), 348, 349 drawLine(), 343 drawOval(), 343, 344 drawPolygon(), 343, 345 drawPolyline(), 343 drawRect(), 343 drawRectangle(), 345 drawRoundRect(), 343, 345 drawString(), 335, 336, 338, 361 dynamic binding, 196 dziedziczenie, 115, 116, 137 interfejsy, 222 klasy abstrakcyjne, 202 klasy bazowe, 116 klasy finalne, 149 klasy potomne, 116 klasy wewnĊtrzne, 238 konstruktory, 119 przesáanianie skáadowych, 139 wywoáanie konstruktora klasy bazowej, 121 dzielenie modulo, 31 dzielenie przez zero, 165 dĨwiĊki, 350, 357 AudioClip, 358 formaty plików dĨwiĊkowych, 357 odtwarzanie, 357, 358 E early binding, 197 Eclipse, 6 edytor tekstowy, 6 elipsy, 344 else, 43 empty(), 309 enhanced for, 60 ensureCapacity(), 307 equals(), 254, 275 escape sequence, 29 etykietowany break, 66 etykietowany continue, 66, 67 etykiety, 66 etykiety tekstowe, 377 exception, 161 Exception, 168, 173, 178 exists(), 275, 282, 283, 289 EXIT_ON_CLOSE, 361 extends, 116, 222 F false, 18, 39 figury geometryczne, 342 File, 266, 274, 277, 279, 297 FileDescriptor, 297 FileInputStream, 295 FilenameFilter, 278, 279 FileNotFoundException, 287, 289, 291, 296, 297 Skorowidz 393 FileOutputStream, 297 FileReader, 295, 296 FileWriter, 298 fillOval(), 343, 344 fillPolygon(), 343, 346 fillRect(), 343 fillRectangle(), 345 fillRoundRect(), 343, 345 final, 149, 150, 154 finalize(), 112, 113 finally, 180 finalne argumenty, 154 finalne klasy, 149 finalne pola, 150 float, 18 Float, 258 flush(), 268, 270 Font, 333, 334, 336 Font.BOLD, 335 Font.ITALIC, 335 Font.PLAIN, 335 FontMetrics, 337, 338 fonty, 333 for, 54 foreach, 60 format(), 268, 270, 271 formaty plików dĨwiĊkowych, 357 Frame, 360 G garbage collector, 113 gDC, 337 get(), 302, 305, 307, 318 getAbsoluteFile(), 275 getAbsolutePath(), 275 getAllFonts(), 335, 336 getAudioClip(), 358, 359 getAvailableFontFamilyNames(), 335, 336 getBackground(), 376 getBounds(), 376 getButton(), 352, 353 getCanonicalFile(), 275 getCanonicalPath(), 275 getChannel(), 286 getCodeBase(), 347 getComponent(), 375 getCursor(), 376 getDocument(), 382 getDocumentBase(), 347 getFD(), 286 getFilePointer(), 286 getFont(), 376 getFontMetrics(), 338, 376 getFontName(), 336 getForeground(), 376 getFreeSpace(), 275 getGraphics(), 377 getHeight(), 337, 338, 377 getImage(), 347 getItemAt(), 387 getItemCount(), 387 getLocalGraphicsEnvironment(), 336 getMessage(), 167 getModifiers(), 356 getName(), 275, 377 getParameter(), 333, 341 getParent(), 275, 377 getParentFile(), 275 getPath(), 275, 284 getSelectedIndex(), 387, 389 getSelectedItem(), 387, 389 getSize(), 328, 377 getSource(), 369, 373 getText(), 377, 382 getTotalSpace(), 276 getUsableSpace(), 276 getWidth(), 377 getX(), 352, 356, 377 getY(), 352, 356, 377 GIF, 347 grafika, 328, 342 elipsy, 344 figury geometryczne, 342 Graphics, 342 koáa, 344 linie, 342 obrazy, 347 odĞwieĪanie ekranu, 350 prostokąt o zaokrąglonych rogach, 345 punkty, 342 rysowanie, 342 wczytywanie grafiki, 347 wielokąty, 345 Graphics, 328, 338, 342 metody, 343 GraphicsEnvironment, 335, 336 GridLayout, 386 H hashCode(), 276 hasNext(), 266, 311, 313 hasNextByte(), 266 hasNextDouble(), 266 hasNextInt(), 266, 267 hasNextLine(), 266 heap, 88 height, 328 hierarchia klas, 213 hierarchia wyjątków, 168 historia Javy, 5 HTML, 329, 330 I if...else, 43 if…else if, 46 iloczyn logiczny, 39 ImageObserver, 342, 348, 349, 350 ImageObserver.ALLBITS, 350 imageUpdate(), 349 implementacja interfejsu, 212 implementacja wielu interfejsów, 217 implements, 212, 215, 217 import, 131, 268 indeksowanie tablicy, 157 indexOf(), 307 inicjalizacja, 22 obiekty, 104 pola finalne, 152 tablice, 72 init(), 331, 333 initialization, 22 initiation, 22 inkrementacja, 31, 32 InputEvent, 356 InputReader, 266 InputStream, 249, 250, 251, 252, 267 InputStreamReader, 252 insertItemAt(), 387 insertUpdate(), 382 instalacja JDK, 9 instrukcje sterujące, 43 Linux, 10 Windows, 10 instrukcje, 21 int, 17, 35 Integer, 257 interface, 211 interfejsy, 211 ActionListener, 367, 381 AudioClip, 358 deklaracja, 211 DocumentListener, 382 394 Praktyczny kurs Java interfejsy dziedziczenie, 222 FilenameFilter, 279 hierarchia klas, 213 ImageObserver, 349 implementacja, 212 ItemListener, 371 Iterable, 311 konflikty nazw, 219, 223 MouseListener, 351, 353 MouseMotionListener, 355 pola, 216 Readable, 266 ReadableByteChannel, 266 Runnable, 361 WindowListener, 361 invokeLater(), 361 IOException, 251, 258, 261, 282 isAbsolute(), 276 isDirectory(), 276 isEditable(), 387 isEmpty(), 307 isFile(), 276 isHidden(), 276 isPopupTrigger(), 374 ItemListener, 371, 373 itemStateChanged(), 371, 373 Iterable, 311, 312 metody, 311 iteracja po kolekcji, 60 iterator(), 311, 312 iteratory, 311 J JApplet, 328 java, 14 Java, 5 Java 2, 7 Java 2 Platform, 7 Java 6, 7 Java 7, 7 java compiler, 13 Java Development Kit, 6, 9 Java Enterprise Edition, 7 Java Mobile Edition, 7 Java Runtime Environment, 6, 10 Java SE 6, 7 Java Standard Edition, 7 Java Virtual Machine, 14 java.awt, 328, 334, 360 java.awt.event, 351 java.io, 251 java.util.regex, 280 javac, 13 javax.swing, 328, 360 javax.swing.event, 364 jawna konwersja, 186 JButton, 379 JCheckBox, 385 konstruktory, 385 JCheckBoxMenuItem, 371, 373 JComboBox, 387 konstruktory, 387 metody, 387 JComponent, 376, 380 JDK, 6 instalacja, 9 przygotowanie do pracy, 11 JEditorPane, 380 jednostka kompilacji, 134 jednowierszowe pole tekstowe, 380 jĊzyk Java, 5 JFormattedTextField, 380 JFrame, 360 JLabel, 377 JMenu, 365, 369 JMenuBar, 365, 366 JMenuItem, 365, 366, 367, 371, 374 JPasswordField, 380 JPG, 347 JPopupMenu, 373, 374 JRE, 6, 10 JTextArea, 380, 383 konstruktory, 383 JTextComponent, 380 JTextField, 380, 382 konstruktory, 381 JTextPane, 380 K kaskadowe menu, 369 katalogi, 277 tworzenie, 281, 282 usuwanie, 283 klasy, 15, 16, 86 ActionEvent, 369 Applet, 328, 333 ArrayList, 306 BufferedInputStream, 299 BufferedOutputStream, 299 BufferedReader, 252, 260, 290 CheckBoxMenu, 371 Color, 338 Component, 376 Console, 259, 267 definicja, 86 dziedziczenie, 115, 116 Exception, 168, 173 File, 274 FileInputStream, 295 FileReader, 295 Font, 333, 334 FontMetrics, 337 Graphics, 328, 342 GraphicsEnvironment, 335, 336 GridLayout, 386 hierarchia klas, 213 ImageObserver, 350 implementacja interfejsu, 212 implementacja wielu interfejsów, 217 inicjalizacja pól finalnych, 152 InputEvent, 356 InputStream, 250, 251 InputStreamReader, 252 Integer, 257 JApplet, 328 JButton, 379 JCheckBox, 385 JCheckBoxMenuItem, 371 JComboBox, 387 JComponent, 376 JEditorPane, 380 JFormattedTextField, 380 JFrame, 360 JLabel, 377 JMenu, 365 JMenuBar, 365, 366 JMenuItem, 365, 366 JPasswordField, 380 JPopupMenu, 373 JTextArea, 380, 383 JTextField, 380 JTextPane, 380 klasy bazowe, 116 klasy finalne, 149 klasy kontenerowe, 301, 305 klasy nadrzĊdne, 116 klasy pakietowe, 134, 236 klasy podrzĊdne, 116 klasy potomne, 116 klasy publiczne, 134 klasy statyczne, 246 klasy zagnieĪdĪone, 241, 246 klasy zewnĊtrzne, 231 konstruktory, 104 metody, 89 metody finalne, 154 Skorowidz 395 metody prywatne, 199, 200 metody statyczne, 144 MouseAdapter, 374 MouseEvent, 351, 356 MouseInputAdapter, 364, 365 nazwy, 87 Object, 191 odwoáanie do skáadowych, 88 OutputStreamWriter, 272, 297 pakiety, 130 Pattern, 280 pola, 86, 87 pola statyczne, 146 Polygon, 346 PrintStream, 270 PrintWriter, 272, 273 RandomAccessFile, 285 RuntimeException, 168 Scanner, 259, 266 skáadowe, 86 skáadowe statyczne, 144 specyfikatory dostĊpu, 123 Stack, 308 StreamTokenizer, 259 String, 254 SwingUtilities, 361 System, 249 Throwable, 168, 173 tworzenie obiektu, 87 URL, 347, 357 wartoĞci domyĞlne pól, 92 WindowAdapter, 363 wyjątki, 168 klasy abstrakcyjne, 202 definicja, 203 klasy anonimowe, 241, 243 obsáuga zdarzeĔ, 363 tworzenie, 243 klasy wewnĊtrzne, 225 deklaracja, 225 dostĊp do klasy zewnĊtrznej, 231 dziedziczenie z klasy zewnĊtrznej, 238 kilka klas wewnĊtrznych, 227 klasy chronione, 237 klasy pakietowe, 237 klasy prywatne, 237 klasy publiczne, 237 obiekty, 233 rodzaje klas wewnĊtrznych, 236 skáadowe, 228 tworzenie, 225 umiejscowienie klasy wewnĊtrznej, 230 kod ASCII, 250 kod HTML, 330 kod poĞredni, 14 kodowanie znaków, 27, 271 kolekcje, 60 kolory, 338, 344 RGB, 340 koáa, 344 komentarze, 18 komentarz blokowy, 19 komentarz liniowy (wierszowy), 20 kompilacja, 13 kompilator, 13 komponenty, 376 Component, 376 etykiety, 377 JButton, 379 JCheckBox, 385 JComboBox, 387 JComponent, 376 JEditorPane, 380 JFormattedTextField, 380 JLabel, 377 JPasswordField, 380 JTextArea, 380, 383 JTextField, 380 JTextPane, 380 listy rozwijane, 387 menedĪery ukáadu, 386 pola tekstowe, 380 pola wyboru, 385 przyciski, 379 rozkáad elementów w oknie, 379 Swing, 328 komunikat o wyjątku, 167 konflikty nazw, 219, 223 konsola, 12, 267 konstruktory, 104, 202 argumenty, 105 deklaracja, 104 dziedziczenie, 119 klasy bazowe, 119 klasy potomne, 119 konstruktor domyĞlny, 207 odwoáanie do obiektu bieĪącego, 108 przeciąĪanie, 106 this, 108 wywoáanie, 205 wywoáanie innego konstruktora, 110 wywoáanie konstruktora klasy bazowej, 121 wywoáanie metod, 109, 209 kontenery, 301 ArrayList, 306 iteratory, 311 klasy kontenerowe, 305 listy, 306 przeglądanie kontenerów, 310 Stack, 308 stos, 308 stosowanie, 317 kontrola typów, 314 konwersja typów, 35, 185 konwersja typów prostych, 186 konwersje automatyczne, 35 kopiowanie plików, 291, 299 kroje pisma, 333, 334 L labeled break, 66 labeled continue, 66 lastIndexOf(), 307 lastModified(), 276 late binding, 196 length, 72 tablice wielowymiarowe, 77 length(), 276, 286 liczby caákowite, 17, 35 liczby zmiennopozycyjne, 18 linie, 342 Linux, 10 list(), 276, 277, 280 listFiles(), 276 listRoots(), 276 listy, 306 listy rozwijane, 387 logiczna negacja, 40 logiczna suma, 39 logiczny iloczyn, 39 long, 17 loop(), 358 M main(), 99, 101, 145 Main.class, 14 Main.java, 13 mark(), 250 markSupported(), 250 matcher(), 280 matches(), 281 menu, 365 396 Praktyczny kurs Java menu kaskadowe, 369 menu kontekstowe, 373 metody, 89 addActionListener(), 353, 354 argumenty, 94 argumenty finalne, 154 deklaracja, 89 dispose(), 363 drawString(), 335, 336 equals(), 254 finalize(), 112, 113 get(), 302, 318 getParameter(), 333 hasNext(), 313 init(), 331, 333 iterator(), 311 konstruktory, 104 main(), 99, 101, 145 metody abstrakcyjne, 204 metody finalne, 154 metody prywatne, 199 next(), 313 obiekt jako argument, 96 paint(), 328, 333, 336 przeciąĪanie, 102 przesáanianie, 137, 139 repaint(), 350, 354 return, 91 set(), 302, 304, 318 setFont(), 335 specyfikatory dostĊpu, 124 start(), 331 stop(), 331 super(), 121 toString(), 192 typy uogólnione, 322 wartoĞü zwracana, 89 wyjątki, 173 wywoáanie, 90 zwracanie wartoĞci, 91 zwracanie wielu wartoĞci, 323 metody statyczne, 144 deklaracja, 144 wywoáanie, 145 MIDI, 357 mkdir(), 276, 282 mkdirs(), 276, 282 modyfikatory dostĊpu, 123 MouseAdapter, 374 mouseClicked(), 351, 353 mouseDragged(), 355, 356 mouseEntered(), 351, 353 MouseEvent, 351, 356, 375 MouseEvent.ALT_DOWN_ MASK, 356 MouseEvent.BUTTON1, 352 MouseEvent.BUTTON2, 352 MouseEvent.BUTTON3, 352 MouseEvent.CTRL_DOWN_ MASK, 356 MouseEvent.NOBUTTON, 352 MouseEvent.SHIFT_DOWN, 356 MouseEvent.SHIFT_DOWN_ MASK, 356 mouseExited(), 351, 353 MouseInputAdapter, 364, 365 MouseListener, 351, 353, 359, 364, 374 metody, 351 MouseMotionListener, 355 mouseMoved(), 355, 356 mousePressed(), 351, 353, 374 mouseReleased(), 351, 353, 374 mysz, 350, 364 N narzĊdzia, 6 nazwy klasy, 15, 87 pakiety, 131 pliki Ĩródáowe, 15 zmienne, 22, 24 negacja logiczna, 40 NetBeans, 6 new, 70, 87, 118 next(), 311, 313 nextByte(), 266 nextDouble(), 266 nextInt(), 266 nextLine(), 266 nextToken(), 263 niszczenie obiektów, 113 NOT, 38, 40 null, 25, 87 NullPointerException, 171, 255 NumberFormatException, 257, 341 O Oak, 5 obiektowoĞü, 15 obiekty, 16, 104 destruktory, 112 inicjalizacja, 104 inicjalizacja pól finalnych, 152 klasy wewnĊtrzne, 233 konstruktory, 104 metody, 89 metody finalne, 154 porównywanie obiektów, 254 tworzenie, 87 typy uogólnione, 321 wyjątki, 165 Object, 168, 191, 323 object types, 24 obrazy graficzne, 347 obsáuga konsoli, 267 obsáuga myszy, 350 MouseEvent, 351, 356 MouseInputAdapter, 364 MouseListener, 351, 353 MouseMotionListener, 355 parametry zdarzenia, 356 wspóárzĊdne poáoĪenia kursora myszy, 355 zdarzenia, 351 obsáuga wyjątków, 166 obsáuga zdarzeĔ, 353, 361 klasy anonimowe, 363 odczyt bajtów ze strumienia, 250 odczyt danych z plików, 288, 295 odĞmiecacz, 113 odĞwieĪanie ekranu, 350 odtwarzanie klipu dĨwiĊkowego, 357 odwoáanie do obiektu bieĪącego, 108 odwoáanie do przesáoniĊtego odwoáanie do skáadowych pola, 143 klasy, 88 odwrócona nazwa domeny, 131 okna, 360 dziaáanie wykonywane podczas zamykania, 361 JFrame, 360 menedĪery ukáadu, 386 rozkáad elementów, 379 rozmiar, 360 WindowListener, 362 wyĞwietlanie, 361 zdarzenia, 361 OpenJDK, 6 operacje graficzne, 328 operacje na bitach, 38 operacje na plikach, 285, 287 operacje na tablicach, 69 operacje na zmiennych, 30 Skorowidz 397 operacje wyjĞciowe, 249 operatory, 30 operacje strumieniowe, 294 pliki o dostĊpie swobodnym, przechwytywanie wyjątków, 157 przechwytywanie wielu new, 70 operator warunkowy, 53 operatory arytmetyczne, 31 operatory bitowe, 38 operatory logiczne, 39 operatory porównywania, 41 operatory relacyjne, 41 priorytety operatorów, 42 przypisanie, 40 OR, 38, 39 OutputStreamWriter, 272, 273, 297 overloading, 102 overriding, 139 P package, 130 paint(), 328, 333, 336 pakiet JDK, 6 pakiety, 130 nazwy, 131 odwrócona nazwa domeny, 131 stosowanie, 132 tworzenie, 130 parametry, 94, 96 parametry apletu, 332 parametry wiersza poleceĔ, 100 parametry wywoáania programu, 100 parametry zdarzenia, 356 parseDouble(), 258 parseFloat(), 258 parseInt(), 257, 258 pasek menu, 365 PATH, 12 Pattern, 280 peek(), 309 pĊtle, 54 break, 62 continue, 62, 64 do...while, 59 for, 54 foreach, 60 przejĞcie do kolejnej iteracji, 64 przerwanie wykonania, 62 while, 57 play(), 357 pliki, 274, 281 kopiowanie, 291, 299 odczyt danych, 288, 295 operacje, 285 285 tryb otwarcia, 287 tworzenie, 281 usuwanie, 283 zapis danych, 289, 296 PNG, 347 pobieranie zawartoĞci katalogu, 277 pola, 86, 87 interfejsy, 216 pola statyczne, 146 przesáanianie, 139, 142 wartoĞci domyĞlne, 92 pola finalne, 150 inicjalizacja, 152 pola typów prostych, 150 pola typów referencyjnych, 151 pola tekstowe, 380 pola wyboru, 385 polimorficzne wywoáywanie metod, 210 polimorfizm, 185, 196 polskie znaki, 27, 271 Polygon, 346 ponowne zgáoszenie przechwyconego wyjątku, 175 pop(), 308, 309 porównania, 41 porównanie obiektów, 254 póĨne wiązanie, 194, 196 print(), 271 printf(), 268, 269, 271 znaczniki formatujące, 269 println(), 251, 271 PrintStream, 270, 272 PrintWriter, 272, 273 priorytety operatorów, 42 private, 124, 127 program, 13, 360 parametry wywoáania, 100 punkt startowy, 99 struktura, 13 uruchamianie, 14 programowanie, 9, 13 programowanie obiektowe, 16, 85, 185 prostokąt o zaokrąglonych rogach, 345 protected, 126, 127 prywatne skáadowe, 124 przechowywanie wielu danych, 301 wyjątków, 169 przeciąĪanie konstruktory, 106 metody, 94, 102, 137 przeglądanie kontenerów, 310 przekroczenie zakresu wartoĞci, 37 przesáanianie metody, 137, 139 pola, 139, 142 przesuniĊcie bitowe, 38 przetwarzanie kolekcji, 60 przyciski, 379 przypisanie, 22, 40 public, 100, 123 publiczne skáadowe, 123 punkt startowy programu, 99 punkty, 342 push(), 308, 309, 310 R RandomAccessFile, 285, 287, 289 kopiowanie plików, 291 odczyt danych z pliku, 288 operacje na plikach, 287 zapis danych do pliku, 289 read(), 250, 251, 286, 294, 295 Readable, 266 ReadableByteChannel, 266 readBoolean(), 286 readByte(), 286 readChar(), 286 readDouble(), 286 reader(), 268 readFloat(), 286 readFully(), 286 readInt(), 286 readLine(), 251, 252, 253, 259, 268, 286, 289 readLong(), 286 readPassword(), 268 readShort(), 286 readUnsignedByte(), 286 readUnsignedShort(), 286 readUTF(), 286 reference types, 24 referencje, 25, 152 remove(), 307, 311 removeAllItems(), 387 removeItem(), 387 398 Praktyczny kurs Java removeItemAt(), 387 removeRange(), 307 removeUpdate(), 382 renameTo(), 276 repaint(), 350, 354, 377 reset(), 250 resize(), 303, 305 return, 91, 160, 282 RGB, 340 rodzaje klas wewnĊtrznych, 236 rozkáad elementów w oknie, 379 rozmiar tablicy, 72 run(), 361 Runnable, 361 runtime binding, 196 RuntimeException, 168, 169 rysowanie, 328, 329 figury geometryczne, 342 kolory, 344 rzeczywisty typ obiektu, 194 rzutowanie na interfejs, 243 rzutowanie na typ Object, 191 rzutowanie typów obiektowych, 185, 187, 190, 241 rzutowanie w górĊ, 196, 319 S Scanner, 259, 266, 267 search(), 309 seek(), 286 sekwencje ucieczki, 29 sekwencje znaków specjalnych, set(), 304, 305, 307, 318 setBackground(), 377 setBounds(), 377, 378 setColor(), 328, 338, 344 setCursor(), 377 setDefaultCloseOperation(), 361 setEditable(), 387 setError(), 271 setExecutable(), 276 setFont(), 335, 337, 377 setJMenuBar(), 365 setLastModified(), 276 setLayout(), 379, 386 setLength(), 286 setLocation(), 377 setName(), 377 setReadable(), 276, 277 setReadOnly(), 277 setSelectedIndex(), 387 setSelectedItem(), 387 29 setSize(), 360, 377 setText(), 377, 378, 379, 380 setTitle(), 382 setVisible(), 361, 377 setWriteable(), 277 short, 17 size(), 303, 305, 307 skip(), 250 skáadowe, 86 skáadowe klas wewnĊtrznych, 228 skáadowe statyczne, 144 specyfikatory dostĊpu, 123 specyfikatory dostĊpu, 123 sprawdzanie poprawnoĞci private, 124 protected, 126 public, 123 danych, 157 stack, 88 Stack, 308, 310 metody, 309 staáe kolorów, 339 standardowe wejĞcie, 249, 259 standardowe wyjĞcie, 259 standardowy strumieĔ wejĞciowy, 249 start(), 331, 358 static, 100, 144, 146 statyczne pola, 146 sterta, 88 stop(), 331, 358 stos, 88, 308 StreamTokenizer, 259, 261, 263 ttype, 260 StreamTokenizer.TT_EOF, 260 StreamTokenizer.TT_EOL, 260 StreamTokenizer.TT_NUMBER, StreamTokenizer.TT_WORD, 260 260 String, 100, 254, 266 string(), 338 stringWidth(), 337 strona HTML, 329 struktura programu, 13 struktury danych, 69, 301 strumienie, 249 BufferedInputStream, 299 BufferedOutputStream, 299 BufferedReader, 252 buforowanie, 299 InputStream, 250, 251 InputStreamReader, 252 odczyt bajtów, 250 OutputStreamWriter, 272 PrintStream, 270 PrintWriter, 272, 273 standardowe wejĞcie, 259 standardowe wyjĞcie, 259 standardowy strumieĔ wejĞciowy, 249 System.in, 249 System.out, 249 wczytywanie tekstu, 251 wprowadzanie liczb, 256 wyjĞcie, 249 strumieniowe operacje na plikach, 294 FileInputStream, 295 kopiowanie plików, 299 odczyt danych, 295 zapis do pliku, 296 styl czcionki, 335 suma logiczna, 39 Sun Microsystems, 5 super(), 121, 140 Swing, 328 obsáuga zdarzeĔ, 361 SwingUtilities, 361 switch, 49, 50, 52 break, 50, 52 case, 50, 52 default, 50 System, 249 system dwójkowy, 38 system dziesiĊtny, 38 system plików, 274 File, 274 katalogi, 277, 281 pliki, 281 pobieranie zawartoĞci katalogu, 277 usuwanie katalogów, 283 usuwanie plików, 283 system wejĞcia-wyjĞcia, 249 System.console(), 267 System.gc(), 114 System.in, 249 System.out, 249, 273 System.out.print(), 30 System.out.println(), 25, 26, 193, 251, 296 ć Ğrodowisko programistyczne, 6 Skorowidz T tablice, 69 deklaracja, 70 elementy, 71 indeksy, 71, 157 inicjalizacja, 72 length, 72 odwoáanie do nieistniejącego elementu, 158 operacje, 69 rozmiar tablicy, 72 tworzenie, 70 tablice nieregularne, 79 deklaracja, 79 wyĞwietlanie danych, 81 tablice wielowymiarowe, 74 length, 77 tablice dwuwymiarowe, 74 tworzenie, 75 wyĞwietlanie zawartoĞci, 76 testowanie apletów, 330 this, 108, 110, 111 throw, 173, 174, 175, 302 Throwable, 168, 173 throws, 173 toArray(), 307 tokeny, 259 toString(), 192, 277 toURI(), 277 toURL(), 277 true, 18, 39 True Type, 28 try…catch, 157, 162 tworzenie aplety, 328 aplikacje, 360 interfejsy, 211 katalogi, 281, 282 klasy anonimowe, 243 klasy wewnĊtrzne, 225 listy, 306 menu, 365 menu kontekstowe, 374 obiekty, 87 obiekty klas wewnĊtrznych, 235 pakiety, 130 pliki, 281 tablice, 70 tablice nieregularne, 80 tablice wielowymiarowe, 75 wyjątki, 178 typ obiektu, 16 type(), 321, 324 typy danych, 15, 17 arytmetyczne caákowitoliczbowe, 17 arytmetyczne zmiennopozycyjne, 18 boolean, 18 byte, 17 char, 18 domyĞlne wartoĞci, 93 double, 18 float, 18 int, 17 konwersja, 35, 185 long, 17 short, 17 znaki, 18 typy referencyjne, 24 typy uogólnione, 301, 314 definicja, 319 metody, 322 stosowanie, 318 tworzenie obiektu, 321 U ukrywanie wnĊtrza klasy, 127 umiejscowienie klasy wewnĊtrznej, 230 umieszczanie apletów na stronie, Unicode, 28 UnsupportedEncodingException, UnsupportedOperationException, 329 272 313 uogólnianie metod, 322 URL, 347, 357 uruchamianie apletu, 331 uruchamianie programu, 14 usuwanie katalogi, 283 obiekty, 113 pliki, 283 V void, 89, 90, 94 W wartoĞci domyĞlne pól, 92 wartoĞci null, 87 wartoĞü pusta, 25 399 WAVE, 357 wbudowane typy danych, 17 wczesne wiązanie, 197 wczytywanie grafika, 347 tekst, 251 wejĞcie, 249 wersje Javy, 7 wersje JDK, 7 wewnĊtrzne klasy statyczne, 246 while, 57, 253, 254 wiązanie czasu wykonania, 196 wiązanie dynamiczne, 196 width, 328 wielokąty, 345 windowActivated(), 362 WindowAdapter, 363 windowClosed(), 362 windowClosing(), 362, 363 windowDeactivated(), 362 windowDeiconified(), 362 windowIconified(), 362 WindowListener, 361, 362, 363 metody, 362 windowOpened(), 362 Windows, 10 wirtualna maszyna Javy, 14 wáasne wyjątki, 173 wprowadzanie danych w rzeczywistych aplikacjach, 262 wprowadzanie liczb, 256 write(), 271, 286, 297 writeBoolean(), 286 writeByte(), 287 writeBytes(), 287, 291 writeChar(), 287 writeChars(), 287 writeDouble(), 287 writeFloat(), 287 writeInt(), 287, 289 writeLong(), 287 writer(), 268 writeShort(), 287 writeUTF(), 287 wspóárzĊdne poáoĪenia kursora myszy, 355 wyjątki, 157, 161 ArithmeticException, 165 ArrayIndexOutOfBoundsExc eption, 161, 302 ClassCastException, 315 Exception, 168, 173, 178 FileNotFoundException, 287 400 Praktyczny kurs Java hierarchia wyjątków, 168 IOException, 251, 258, 282 klasy, 168 komunikat o wyjątku, 167 NullPointerException, 171, 255 NumberFormatException, 257, 341 obiekty, 165, 166 ponowne zgáoszenie przechwyconego wyjątku, 175 przechwytywanie, 157 przechwytywanie wielu wyjątków, 169 RuntimeException, 168 sekcja finally, 180 throw, 173, 175 Throwable, 168, 173 try…catch, 157, 162 tworzenie wyjątków, 178 UnsupportedEncoding ´Exception, 272 UnsupportedOperation ´Exception, 313 wiele bloków catch, 169 wáasne wyjątki, 173 zagnieĪdĪanie bloków try...catch, 171 zgáaszanie, 173 wyjĞcie, 249, 270 wykonanie programu, 13 wyprowadzanie danych na ekran, 25 wyraĪenia regularne, 280 wyĞwietlanie informacji na ekranie, 249 wyĞwietlanie tekstu, 335 wyĞwietlanie wartoĞci zmiennych, 25 wywoáanie konstruktor klasy bazowej, 121 konstruktory, 205 metody, 90, 197 metody klas pochodnych, 199 metody przesáoniĊte, 140 metody przez konstruktory, 109, 209 metody statyczne, 145 X XOR, 38 Z zagnieĪdĪanie bloków try...catch, 171 zapis danych do pliku, 289, 296 zarządzanie pamiĊcią, 113 zdarzenia, 350 obsáuga, 353, 363 okna, 361 parametry, 356 zgáaszanie wyjątków, 173 zmiana koloru, 338 zmienne, 21 deklaracja, 22 deklaracja wielu zmiennych, 23 inicjalizacja, 22 nazwy, 22, 24 operacje, 30 przypisanie wartoĞci, 22 typy odnoĞnikowe, 24 zmienne odnoĞnikowe, 87 zmienne referencyjne, 24 znaki, 18 znaki specjalne, 28
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Praktyczny kurs Java. Wydanie III
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ą: