Darmowy fragment publikacji:
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.
Redaktor prowadzący: Ewelina Burska
Projekt okładki: Studio Gravite/Olsztyn
Obarek, Pokoński, Pazdrijowski, Zaprucki
Wydawnictwo HELION
ul. Kościuszki 1c, 44-100 GLIWICE
tel. 32 231 22 19, 32 230 98 63
e-mail: helion@helion.pl
WWW: http://helion.pl (księgarnia internetowa, katalog książek)
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/pkjav4
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Listingi wykorzystane w książce można znaleźć pod adresem:
ftp://ftp.helion.pl/przyklady/pkjav4.zip
ISBN: 978-83-246-9663-5
Copyright © Helion 2015
Printed in Poland.
• Kup książkę
• Poleć książkę
• Oceń książkę
• Księgarnia internetowa
• Lubię to! » Nasza społeczność
Spis tre(cid:264)ci
Wst(cid:246)p .............................................................................................. 5
Rozdzia(cid:228) 1. Podstawy ......................................................................................... 9
Instalacja JDK .................................................................................................................. 9
Instalacja w systemie Windows ................................................................................ 10
Instalacja w systemie Linux ..................................................................................... 11
Przygotowanie do pracy z JDK ................................................................................ 11
Podstawy programowania ............................................................................................... 13
Lekcja 1. Struktura programu, kompilacja i wykonanie ........................................... 13
Lekcja 2. Podstawy obiektowo(cid:286)ci i typy danych ...................................................... 16
Lekcja 3. Komentarze ............................................................................................... 19
Rozdzia(cid:228) 2. Instrukcje j(cid:246)zyka ............................................................................ 23
Zmienne .......................................................................................................................... 23
Lekcja 4. Deklaracje i przypisania ........................................................................... 24
Lekcja 5. Wyprowadzanie danych na ekran ............................................................. 27
Lekcja 6. Operacje na zmiennych ............................................................................. 33
Instrukcje steruj(cid:261)ce ......................................................................................................... 47
Lekcja 7. Instrukcja warunkowa if…else ................................................................. 47
Lekcja 8. Instrukcja switch i operator warunkowy ................................................... 53
Lekcja 9. P(cid:266)tle .......................................................................................................... 59
Lekcja 10. Instrukcje break i continue ...................................................................... 66
Tablice ............................................................................................................................ 74
Lekcja 11. Podstawowe operacje na tablicach .......................................................... 74
Lekcja 12. Tablice wielowymiarowe ........................................................................ 79
Rozdzia(cid:228) 3. Programowanie obiektowe. Cz(cid:246)(cid:264)(cid:232) I ................................................. 91
Podstawy ........................................................................................................................ 91
Lekcja 13. Klasy, pola i metody ............................................................................... 91
Lekcja 14. Argumenty i przeci(cid:261)(cid:298)anie metod .......................................................... 100
Lekcja 15. Konstruktory ......................................................................................... 110
Dziedziczenie ............................................................................................................... 121
Lekcja 16. Klasy potomne ...................................................................................... 122
Lekcja 17. Specyfikatory dost(cid:266)pu i pakiety ............................................................ 129
Lekcja 18. Przes(cid:225)anianie metod i sk(cid:225)adowe statyczne ............................................ 144
Lekcja 19. Klasy i sk(cid:225)adowe finalne ....................................................................... 156
Kup książkęPoleć książkę4
Java. Praktyczny kurs
Rozdzia(cid:228) 4. Wyj(cid:241)tki .......................................................................................... 165
Lekcja 20. Blok try…catch ..................................................................................... 165
Lekcja 21. Wyj(cid:261)tki to obiekty ................................................................................ 173
Lekcja 22. W(cid:225)asne wyj(cid:261)tki ..................................................................................... 182
Rozdzia(cid:228) 5. Programowanie obiektowe. Cz(cid:246)(cid:264)(cid:232) II .............................................. 195
Polimorfizm .................................................................................................................. 195
Lekcja 23. Konwersje typów i rzutowanie obiektów .............................................. 195
Lekcja 24. Pó(cid:296)ne wi(cid:261)zanie i wywo(cid:225)ywanie metod klas pochodnych ..................... 204
Lekcja 25. Konstruktory oraz klasy abstrakcyjne ................................................... 212
Interfejsy ....................................................................................................................... 222
Lekcja 26. Tworzenie interfejsów .......................................................................... 222
Lekcja 27. Wiele interfejsów .................................................................................. 230
Klasy wewn(cid:266)trzne ........................................................................................................ 238
Lekcja 28. Klasa w klasie ....................................................................................... 238
Lekcja 29. Rodzaje klas wewn(cid:266)trznych i dziedziczenie ......................................... 246
Lekcja 30. Klasy anonimowe i zagnie(cid:298)d(cid:298)one ......................................................... 254
Rozdzia(cid:228) 6. System wej(cid:264)cia-wyj(cid:264)cia ................................................................ 269
Lekcja 31. Standardowe wej(cid:286)cie ............................................................................ 269
Lekcja 32. Standardowe wej(cid:286)cie i wyj(cid:286)cie ............................................................. 279
Lekcja 33. System plików ...................................................................................... 295
Lekcja 34. Operacje na plikach .............................................................................. 306
Rozdzia(cid:228) 7. Kontenery i typy uogólnione .......................................................... 323
Lekcja 35. Kontenery ............................................................................................. 323
Lekcja 36. Typy uogólnione ................................................................................... 336
Rozdzia(cid:228) 8. Aplikacje i aplety ......................................................................... 351
Aplety ........................................................................................................................... 351
Lekcja 37. Podstawy apletów ................................................................................. 351
Lekcja 38. Kroje pisma (fonty) i kolory ................................................................. 358
Lekcja 39. Grafika .................................................................................................. 366
Lekcja 40. D(cid:296)wi(cid:266)ki i obs(cid:225)uga myszy ...................................................................... 376
Aplikacje ...................................................................................................................... 386
Lekcja 41. Tworzenie aplikacji .............................................................................. 386
Lekcja 42. Komponenty ......................................................................................... 402
Skorowidz .................................................................................... 417
Kup książkęPoleć książkęRozdzia(cid:228) 6.
System wej(cid:264)cia-wyj(cid:264)cia
Do pisania aplikacji w Javie niezb(cid:266)dna jest znajomo(cid:286)(cid:252) przynajmniej podstaw systemu
wej(cid:286)cia-wyj(cid:286)cia. Tej tematyce jest po(cid:286)wi(cid:266)cony ten rozdzia(cid:225). W Javie operacje wej-
(cid:286)cia-wyj(cid:286)cia s(cid:261) wykonywane za pomoc(cid:261) strumieni. Strumie(cid:276) to abstrakcyjny ci(cid:261)g da-
nych, który dzia(cid:225)a — mówi(cid:261)c w uproszczeniu — w taki sposób, (cid:298)e dane wprowadzone
na jednym jego ko(cid:276)cu pojawiaj(cid:261) si(cid:266) na drugim ko(cid:276)cu. Strumienie dziel(cid:261) si(cid:266) na wej(cid:286)ciowe
i wyj(cid:286)ciowe. Strumienie wyj(cid:286)ciowe maj(cid:261) pocz(cid:261)tek w aplikacji i koniec w innym urz(cid:261)-
dzeniu, np. na ekranie czy w pliku, umo(cid:298)liwiaj(cid:261) zatem wyprowadzanie danych z pro-
gramu. Przyk(cid:225)adowo standardowy strumie(cid:276) wyj(cid:286)ciowy jest reprezentowany przez obiekt
System.out, a wykonanie metody println tego obiektu powoduje, (cid:298)e dane domy(cid:286)lnie zo-
staj(cid:261) wys(cid:225)ane na ekran. Strumienie wej(cid:286)ciowe dzia(cid:225)aj(cid:261) odwrotnie: ich pocz(cid:261)tek znajduje
si(cid:266) poza aplikacj(cid:261) (mo(cid:298)e to by(cid:252) np. klawiatura albo plik dyskowy), a koniec w aplikacji,
umo(cid:298)liwiaj(cid:261) zatem wprowadzanie danych. Co wi(cid:266)cej, strumienie umo(cid:298)liwiaj(cid:261) te(cid:298) ko-
munikacj(cid:266) mi(cid:266)dzy obiektami w obr(cid:266)bie jednej aplikacji. W tym rozdziale zostanie
jednak omówiona tylko komunikacja aplikacji ze (cid:286)wiatem zewn(cid:266)trznym.
Lekcja 31. Standardowe wej(cid:264)cie
Opisy podstawowych operacji wyj(cid:286)ciowych, czyli wy(cid:286)wietlania informacji na ekranie
konsoli, pojawi(cid:225)y si(cid:266) ju(cid:298) wielokrotnie; operacje te zostan(cid:261) dok(cid:225)adniej przedstawione
w ramach kolejnej lekcji. Omówienie systemu wej(cid:286)cia-wyj(cid:286)cia rozpoczniemy od wpro-
wadzania danych i standardowego strumienia wej(cid:286)ciowego reprezentowanego przez
obiekt System.in. Tej tematyce zostanie po(cid:286)wi(cid:266)cona ca(cid:225)a bie(cid:298)(cid:261)ca lekcja. Zostan(cid:261) w niej
przedstawione informacje, jak odczytywa(cid:252) dane wprowadzane przez u(cid:298)ytkownika
z klawiatury.
Standardowy strumie(cid:254) wej(cid:264)ciowy
Standardowy strumie(cid:276) wej(cid:286)ciowy jest reprezentowany przez obiekt System.in, czyli
obiekt in zawarty w klasie System. Jest to obiekt typu InputStream, klasy reprezentu-
j(cid:261)cej strumie(cid:276) wej(cid:286)ciowy. Metody udost(cid:266)pniane przez t(cid:266) klas(cid:266) s(cid:261) zebrane w tabeli 6.1. Jak
wida(cid:252), nie jest to imponuj(cid:261)cy zestaw, niemniej jest to podstawowa klasa operuj(cid:261)ca na
strumieniu wej(cid:286)ciowym.
Kup książkęPoleć książkę270
Java. Praktyczny kurs
Tabela 6.1. Metody udost(cid:266)pniane przez klas(cid:266) InputStream
Deklaracja metody
int available()
void close()
void mark(int
readlimit)
boolean markSupported()
abstract int read()
int read(byte[] b)
int read(byte[] b,
int off, int len)
void reset()
long skip(long n)
Opis
Zwraca przewidywan(cid:261) liczb(cid:266) bajtów, które mog(cid:261) by(cid:252) pobrane
ze strumienia przy najbli(cid:298)szym odczycie.
Zamyka strumie(cid:276) i zwalnia zwi(cid:261)zane z nim zasoby.
Zaznacza bie(cid:298)(cid:261)c(cid:261) pozycj(cid:266) w strumieniu.
Sprawdza, czy strumie(cid:276) mo(cid:298)e obs(cid:225)ugiwa(cid:252) metody mark i reset.
Odczytuje kolejny bajt ze strumienia.
Odczytuje ze strumienia liczb(cid:266) bajtów nie wi(cid:266)ksz(cid:261) ni(cid:298) rozmiar tablicy
b. Zwraca rzeczywi(cid:286)cie odczytan(cid:261) liczb(cid:266) bajtów.
Odczytuje ze strumienia liczb(cid:266) bajtów nie wi(cid:266)ksz(cid:261) ni(cid:298) okre(cid:286)lona
przez len i zapisuje je w tablicy b, pocz(cid:261)wszy od komórki wskazywanej
przez off. Zwraca rzeczywi(cid:286)cie przeczytan(cid:261) liczb(cid:266) bajtów.
Wraca do pozycji strumienia wskazywanej przez wywo(cid:225)anie metody mark.
Pomija w strumieniu liczb(cid:266) bajtów wskazywanych przez n. Zwraca
rzeczywi(cid:286)cie pomini(cid:266)t(cid:261) liczb(cid:266) bajtów.
Wida(cid:252) wyra(cid:296)nie, (cid:298)e odczyt bajtów ze strumienia mo(cid:298)na przeprowadzi(cid:252) za pomoc(cid:261)
jednej z metod o nazwie read. Przyjrzyjmy si(cid:266) metodzie odczytuj(cid:261)cej tylko jeden bajt.
Mimo (cid:298)e odczytuje ona bajt, zwraca warto(cid:286)(cid:252) typu int. Jest tak dlatego, (cid:298)e zwracana
warto(cid:286)(cid:252) zawsze zawiera si(cid:266) w przedziale 0 – 255 (to tyle, ile mo(cid:298)e przyjmowa(cid:252) jeden
bajt). Tymczasem zmienna typu byte reprezentuje warto(cid:286)ci „ze znakiem” w zakresie
od –128 do +1271. Spróbujmy zatem napisa(cid:252) prosty program, który odczyta wprowa-
dzony z klawiatury znak, a nast(cid:266)pnie wy(cid:286)wietli ten znak oraz jego kod ASCII na
ekranie. Kod realizuj(cid:261)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(cid:283) 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(cid:239)(cid:200)d podczas odczytu strumienia. );
}
}
}
1 Oczywi(cid:286)cie reprezentowanie zakresu od 0 do 255 by(cid:225)oby mo(cid:298)liwe równie(cid:298) za pomoc(cid:261) typów short i long.
Kup książkęPoleć książkęRozdzia(cid:228) 6. (cid:105) System wej(cid:264)cia-wyj(cid:264)cia
271
Pierwszym krokiem jest zaimportowanie pakietu java.io (lekcja 17.), znajduje si(cid:266) w nim
bowiem definicja wyj(cid:261)tku IOException, który musimy przechwyci(cid:252). W metodzie main
za pomoc(cid:261) metody System.out.println wy(cid:286)wietlamy tekst z pro(cid:286)b(cid:261) o wprowadzenie
dowolnego znaku z klawiatury, a nast(cid:266)pnie wykonujemy instrukcj(cid:266):
char c = (char) System.in.read();
Wywo(cid:225)ujemy zatem metod(cid:266) read obiektu in zawartego w klasie System2. Obiekt ten jest
klasy InputStream (typem obiektu jest InputStream) i reprezentuje standardowy stru-
mie(cid:276) wej(cid:286)ciowy. W typowym przypadku jest on powi(cid:261)zany z klawiatur(cid:261), wi(cid:266)c z tego
strumienia b(cid:266)d(cid:261) odczytywane dane wprowadzane przez u(cid:298)ytkownika z klawiatury.
Metoda read zwraca warto(cid:286)(cid:252) typu int, dokonujemy zatem konwersji na typ char, tak
aby wy(cid:286)wietli(cid:252) na ekranie wprowadzony znak, i przypisujemy go zmiennej c. Nast(cid:266)pnie
wy(cid:286)wietlamy zawarto(cid:286)(cid:252) tej zmiennej za pomoc(cid:261) instrukcji:
System.out.println(c);
Aby wy(cid:286)wietli(cid:252) kod znaku, nale(cid:298)y ponownie dokona(cid:252) konwersji. Zmienn(cid:261) c typu char
konwertujemy na typ int, tak aby metoda println potraktowa(cid:225)a j(cid:261) jako liczb(cid:266), a nie jako
znak. Poniewa(cid:298) metoda read mo(cid:298)e spowodowa(cid:252) powstanie wyj(cid:261)tku IOException,
wszystkie instrukcje zosta(cid:225)y uj(cid:266)te w blok try, który zapobiegnie niekontrolowanemu
zako(cid:276)czeniu programu (por. lekcje z rozdzia(cid:225)u 4.). Przyk(cid:225)adowy efekt dzia(cid:225)ania programu
z listingu 6.1 jest widoczny na rysunku 6.1.
Rysunek 6.1.
Przyk(cid:225)adowy efekt
dzia(cid:225)ania programu
z listingu 6.1
Trzeba zwróci(cid:252) uwag(cid:266), (cid:298)e w ten sposób tak naprawd(cid:266) odczytywany jest ze strumienia
nie jeden znak, ale jeden bajt. A te poj(cid:266)cia nie s(cid:261) to(cid:298)same. Jeden znak mo(cid:298)e zawiera(cid:252)
w zale(cid:298)no(cid:286)ci od standardu kodowania od jednego do kilku bajtów.
Wczytywanie tekstu
Wiadomo ju(cid:298), jak odczyta(cid:252) jeden bajt, co jednak zrobi(cid:252), aby wprowadzi(cid:252) ca(cid:225)(cid:261) lini(cid:266) tekstu?
Przecie(cid:298) taka sytuacja jest o wiele cz(cid:266)stsza. Mo(cid:298)na oczywi(cid:286)cie odczytywa(cid:252) pojedyn-
cze znaki w p(cid:266)tli tak d(cid:225)ugo, a(cid:298) zostanie osi(cid:261)gni(cid:266)ty znak ko(cid:276)ca linii, oraz po(cid:225)(cid:261)czy(cid:252) je
w obiekt typu String. Najlepiej by(cid:225)oby wr(cid:266)cz wyprowadzi(cid:252) z klasy InputStream klas(cid:266)
pochodn(cid:261), która zawiera(cid:225)aby metod(cid:266) np. o nazwie readLine, wykonuj(cid:261)c(cid:261) tak(cid:261) czynno(cid:286)(cid:252).
Trzeba by(cid:225)oby przy tym pami(cid:266)ta(cid:252) o odpowiedniej obs(cid:225)udze standardów kodowania
znaków. Na szcz(cid:266)(cid:286)cie w JDK zosta(cid:225) zdefiniowany ca(cid:225)y zestaw klas operuj(cid:261)cych na
strumieniach wej(cid:286)ciowych. Zamiast wi(cid:266)c powtarza(cid:252) co(cid:286), co zosta(cid:225)o ju(cid:298) zrobione, najlepiej
po prostu z nich skorzysta(cid:252).
2 Obiekt in jest polem finalnym i statycznym klasy System.
Kup książkęPoleć książkę272
Java. Praktyczny kurs
Zadanie to b(cid:266)dzie wymaga(cid:225)o u(cid:298)ycia dwóch klas po(cid:286)rednicz(cid:261)cych. Klas(cid:261) udost(cid:266)pniaj(cid:261)-
c(cid:261) metod(cid:266) readLine, która jest w stanie prawid(cid:225)owo zinterpretowa(cid:252) znaki przychodz(cid:261)ce ze
strumienia, jest BufferedReader. Aby jednak mo(cid:298)na by(cid:225)o utworzy(cid:252) obiekt takiej klasy,
musi powsta(cid:252) obiekt klasy Reader lub klasy od niej pochodnej — w tym przypadku naj-
odpowiedniejszy b(cid:266)dzie InputStreamReader. Poniewa(cid:298) nie ma takiego obiektu w aplikacji
(do dyspozycji mamy jedynie obiekt System.in typu InputStream), nale(cid:298)y go utwo-
rzy(cid:252), wywo(cid:225)uj(cid:261)c odpowiedni konstruktor. B(cid:266)dzie to obiekt (strumie(cid:276)) po(cid:286)rednicz(cid:261)cy
w wymianie danych. Do jego utworzenia potrzeba z kolei obiektu klasy InputStream,
a tym przecie(cid:298) dysponujemy. Dlatego te(cid:298) kod programu, który odczytuje lini(cid:266) tekstu ze
standardowego wej(cid:286)cia, b(cid:266)dzie wygl(cid:261)da(cid:252) tak, jak zosta(cid:225)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(cid:283) lini(cid:218) tekstu zako(cid:241)czon(cid:200) znakiem Enter: );
try{
String line = brIn.readLine();
System.out.print( Wprowadzona linia to: + line);
}
catch(IOException e){
System.out.println( B(cid:239)(cid:200)d podczas odczytu strumienia. );
}
}
}
Pierwszym zadaniem jest utworzenie obiektu brIn klasy BufferedReader. Mamy tu do
czynienia ze z(cid:225)o(cid:298)on(cid:261) instrukcj(cid:261), która najpierw tworzy obiekt typu InputStreamReader,
wykorzystuj(cid:261)c obiekt System.in, i dopiero ten obiekt przekazuje konstruktorowi klasy
BufferedReader. Zatem konstrukcj(cid:266):
BufferedReader brIn = new BufferedReader(
new InputStreamReader(System.in)
);
mo(cid:298)na równie(cid:298) rozbi(cid:252) na dwie cz(cid:266)(cid:286)ci:
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader brIn = new BufferedReader(isr);
Znaczenie b(cid:266)dzie takie samo, jednak w drugim przypadku zostanie utworzona zupe(cid:225)nie
niepotrzebnie dodatkowa zmienna isr typu InputStreamReader. To, który ze sposobów
jest czytelniejszy i zostanie zastosowany, zale(cid:298)y jednak od indywidualnych preferencji
programisty. Z regu(cid:225)y stosuje si(cid:266) sposób pierwszy.
Kiedy obiekt klasy BufferedReader jest ju(cid:298) utworzony, mo(cid:298)na wykorzysta(cid:252) metod(cid:266)
readLine, która zwróci w postaci obiektu typu String (klasa String reprezentuje ci(cid:261)gi
Kup książkęPoleć książkęRozdzia(cid:228) 6. (cid:105) System wej(cid:264)cia-wyj(cid:264)cia
273
znaków) lini(cid:266) tekstu wprowadzon(cid:261) przez u(cid:298)ytkownika. Linia tekstu jest rozumiana
jako ci(cid:261)g znaków wprowadzony a(cid:298) do naci(cid:286)ni(cid:266)cia klawisza Enter (dok(cid:225)adniej: a(cid:298) do
osi(cid:261)gni(cid:266)cia znaku ko(cid:276)ca wiersza w strumieniu). Wynika z tego, (cid:298)e instrukcja:
String line = brIn.readLine();
utworzy zmienn(cid:261) line typu String i przypisze jej obiekt (referencj(cid:266) do obiektu) zwrócony
przez metod(cid:266) readLine obiektu brIn. Dzia(cid:225)anie programu b(cid:266)dzie zatem nast(cid:266)puj(cid:261)ce:
po uruchomieniu zostanie wy(cid:286)wietlona pro(cid:286)ba o wprowadzenie linii tekstu, nast(cid:266)pnie
linia ta zostanie odczytana i przypisana zmiennej line, a potem zawarto(cid:286)(cid:252) tej zmiennej
zostanie wy(cid:286)wietlona na ekranie. Przyk(cid:225)ad wykonania tego programu pokazano na ry-
sunku 6.2.
Rysunek 6.2.
Wczytanie linii tekstu
za pomoc(cid:261) obiektu
klasy BufferedReader
Skoro wiadomo ju(cid:298), jak wczyta(cid:252) wiersz tekstu z klawiatury, spróbujmy napisa(cid:252) pro-
gram, którego zadaniem b(cid:266)dzie wczytywanie kolejnych linii ze standardowego wej-
(cid:286)cia tak d(cid:225)ugo, a(cid:298) zostanie odczytany ci(cid:261)g znaków quit. Zadanie wydaje si(cid:266) banalne,
wystarczy przecie(cid:298) do kodu z listingu 6.2 doda(cid:252) p(cid:266)tl(cid:266) while, która b(cid:266)dzie sprawdza(cid:225)a, czy
zmienna line zawiera napis quit. W pierwszym odruchu napiszemy zapewne p(cid:266)tl(cid:266),
która b(cid:266)dzie wygl(cid:261)da(cid:252) nast(cid:266)puj(cid:261)co (przy za(cid:225)o(cid:298)eniu, (cid:298)e wcze(cid:286)niej zosta(cid:225) prawid(cid:225)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(cid:252) ten przyk(cid:225)ad. Na pocz(cid:261)tku deklarujemy zmienn(cid:261) line i przypisu-
jemy jej pusty ci(cid:261)g znaków. W p(cid:266)tli while sprawdzamy warunek, czy zmienna line jest
ró(cid:298)na od ci(cid:261)gu znaków quit — je(cid:286)li tak, to p(cid:266)tla jest kontynuowana, a je(cid:286)li nie, to ko(cid:276)czy
dzia(cid:225)anie. Zatem znaczenie jest nast(cid:266)puj(cid:261)ce: dopóki line jest ró(cid:298)ne od quit, wykonuj
instrukcje z wn(cid:266)trza p(cid:266)tli. Wewn(cid:261)trz p(cid:266)tli przypisujemy natomiast zmiennej line
wiersz tekstu odczytany ze standardowego strumienia wej(cid:286)ciowego oraz wy(cid:286)wietlamy
go na ekranie.
Wszystko to wygl(cid:261)da bardzo poprawnie, ma tylko jedn(cid:261) wad(cid:266) — nie zadzia(cid:225)a zgodnie
z za(cid:225)o(cid:298)eniami. Aby si(cid:266) o tym przekona(cid:252), wystarczy uruchomi(cid:252) program z listingu 6.3,
nast(cid:266)pnie wpisa(cid:252) kilka linii tekstu, a po nich ci(cid:261)g znaków quit. Teoretycznie program po-
winien zako(cid:276)czy(cid:252) dzia(cid:225)anie, tymczasem dzia(cid:225)a nadal, co jest widoczne na rysunku 6.3.
Kup książkęPoleć książkęJava. Praktyczny kurs
274
Rysunek 6.3.
B(cid:225)(cid:261)d w p(cid:266)tli while
uniemo(cid:298)liwia
zako(cid:276)czenie programu
Listing 6.3.
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(cid:241)czy(cid:202), 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(cid:239)(cid:200)d podczas odczytu strumienia. );
}
}
}
Co si(cid:266) dzieje, gdzie jest b(cid:225)(cid:261)d? Podejrzenie powinno najpierw pa(cid:286)(cid:252) na warunek zako(cid:276)-
czenia p(cid:266)tli while. On rzeczywi(cid:286)cie jest nieprawid(cid:225)owy, cho(cid:252) wydaje si(cid:266), (cid:298)e instrukcja
ta jest poprawna. Zwró(cid:252)my jednak uwag(cid:266) na to, co tak naprawd(cid:266) jest w tym warunku
porównywane. Mia(cid:225) by(cid:252) porównany ci(cid:261)g znaków zapisany w zmiennej line z ci(cid:261)giem
znaków quit. Tymczasem po umieszczeniu w kodzie sekwencji quit powsta(cid:225) nie-
nazwany obiekt klasy String faktycznie zawieraj(cid:261)cy ci(cid:261)g znaków quit, a w miejsce
napisu quit zosta(cid:225)a wstawiona referencja do tego obiektu. Jak wiadomo z wcze(cid:286)niej-
szych lekcji (lekcja 13.), zmienna line jest tak(cid:298)e referencj(cid:261) do obiektu klasy String.
Instrukcja porównania line != quit porównuje zatem ze sob(cid:261) dwie REFERENCJE,
które w tym przypadku musz(cid:261) by(cid:252) ró(cid:298)ne. W zwi(cid:261)zku z tym nie dochodzi tu do porów-
nania zawarto(cid:286)ci obiektów. Dlatego program nie mo(cid:298)e dzia(cid:225)a(cid:252) poprawnie i wpada w nie-
sko(cid:276)czon(cid:261) p(cid:266)tl(cid:266) (aby zako(cid:276)czy(cid:252) jego dzia(cid:225)anie, trzeba wcisn(cid:261)(cid:252) na klawiaturze kombi-
nacj(cid:266) klawiszy Ctrl+C).
Koniecznie nale(cid:298)y wi(cid:266)c zapami(cid:266)ta(cid:252), (cid:298)e do porównywania obiektów nie u(cid:298)ywa si(cid:266)
operatorów porównywania! Zamiast tego nale(cid:298)y skorzysta(cid:252) z metody equals. Jest ona
zadeklarowana w klasie Object i w zwi(cid:261)zku z tym dziedziczona przez wszystkie klasy.
Kup książkęPoleć książkęRozdzia(cid:228) 6. (cid:105) System wej(cid:264)cia-wyj(cid:264)cia
275
Warto pami(cid:266)ta(cid:252) o tym podczas tworzenia w(cid:225)asnych klas, by w razie potrzeby dopisa(cid:252)
w(cid:225)asn(cid:261) wersj(cid:266) tej metody.
Jak zastosowa(cid:252) t(cid:266) metod(cid:266) w praktyce? Otó(cid:298) zwraca ona warto(cid:286)(cid:252) true, kiedy obiekty
s(cid:261) takie same (czyli ich zawarto(cid:286)(cid:252) jest taka sama), lub false, kiedy obiekty s(cid:261) ró(cid:298)ne.
W przypadku obiektów typu String warto(cid:286)(cid:252) true zostanie zwrócona, je(cid:286)li ci(cid:261)g zna-
ków zapisany w jednym z nich jest taki sam jak ci(cid:261)g znaków zapisany w drugim. Je(cid:298)eli
np. istnieje zmienna zadeklarowana jako:
String napis1 = test ;
to wynikiem operacji:
napis1.equals( test );
b(cid:266)dzie warto(cid:286)(cid:252) true, a wynikiem operacji:
napis1.equals( java );
b(cid:266)dzie warto(cid:286)(cid:252) false.
Powró(cid:252)my teraz do p(cid:266)tli while. Jako (cid:298)e znane s(cid:261) nam ju(cid:298) w(cid:225)a(cid:286)ciwo(cid:286)ci metody equals,
w pierwszej chwili na pewno na my(cid:286)l przyjdzie nam warunek:
while(!line.equals( quit )){
/*instrukcje p(cid:266)tli while*/
}
Je(cid:286)li wprowadzimy go do kodu z listingu 6.3, aplikacja zacznie poprawnie reagowa(cid:252)
na polecenie quit — b(cid:266)dzie si(cid:266) wydawa(cid:252), (cid:298)e ca(cid:225)o(cid:286)(cid:252) nareszcie dzia(cid:225)a prawid(cid:225)owo. W zasa-
dzie mo(cid:298)na by(cid:225)oby si(cid:266) zgodzi(cid:252) z tym stwierdzeniem, gdy(cid:298) program rzeczywi(cid:286)cie dzia(cid:225)a
zgodnie z za(cid:225)o(cid:298)eniami, tylko (cid:298)e teraz zawiera kolejny b(cid:225)(cid:261)d, tym razem du(cid:298)o trudniejszy do
wykrycia. Ujawni si(cid:266) on dopiero przy próbie przerwania pracy aplikacji. Spróbujmy
uruchomi(cid:252) program, a po wpisaniu testowej linii tekstu przerwijmy jego dzia(cid:225)anie
(w wi(cid:266)kszo(cid:286)ci systemów nale(cid:298)y wcisn(cid:261)(cid:252) kombinacj(cid:266) klawiszy Ctrl+C). Efekt jest widoczny
na rysunku 6.4. Zapewne nie spodziewali(cid:286)my si(cid:266) wyj(cid:261)tku NullPointerException…
Rysunek 6.4. Ukryty b(cid:225)(cid:261)d w programie spowodowa(cid:225) wygenerowanie wyj(cid:261)tku
Na przyczyn(cid:266) powstania tego b(cid:225)(cid:266)du naprowadza linia tekstu poprzedzaj(cid:261)ca komunikat
maszyny wirtualnej, mianowicie: Wprowadzona linia to: null. Oznacza to bowiem
(spójrzmy na kod), (cid:298)e metoda readLine obiektu brIn zwróci(cid:225)a — zamiast ci(cid:261)gu znaków
— warto(cid:286)(cid:252) null. Jest to standardowe dzia(cid:225)anie, metoda ta zwraca warto(cid:286)(cid:252) null, kiedy
zostanie osi(cid:261)gni(cid:266)ty koniec strumienia, czyli kiedy nie ma w nim ju(cid:298) (cid:298)adnych danych
do odczytania. Co si(cid:266) dzieje dalej? Otó(cid:298) warto(cid:286)(cid:252) null jest przypisywana zmiennej line,
Kup książkęPoleć książkę276
Java. Praktyczny kurs
a potem w warunku p(cid:266)tli while nast(cid:266)puje próba wywo(cid:225)ania metody equals obiektu
wskazywanego przez line. Tymczasem line ma warto(cid:286)(cid:252) null i nie wskazuje na (cid:298)aden
obiekt. W takiej sytuacji musi zosta(cid:252) wygenerowany wyj(cid:261)tek NullPointerException.
Jak temu zapobiec? Mo(cid:298)liwo(cid:286)ci s(cid:261) dwie: albo dodamy w p(cid:266)tli warunek sprawdzaj(cid:261)cy,
czy line jest równe null, a je(cid:286)li tak, to przerwiemy p(cid:266)tl(cid:266) np. instrukcj(cid:261) break, albo te(cid:298)
zmodyfikujemy sam warunek p(cid:266)tli. Ta druga mo(cid:298)liwo(cid:286)(cid:252) jest lepsza, gdy(cid:298) nie powoduje
wykonywania dodatkowego kodu, a jednocze(cid:286)nie otrzymujemy ciekaw(cid:261) konstrukcj(cid:266).
Poprawiony warunek powinien wygl(cid:261)da(cid:252) nast(cid:266)puj(cid:261)co:
while(! quit .equals(line)){
/*instrukcje p(cid:266)tli while*/
}
Pocz(cid:261)tkowo tego typu zapis budzi zdziwienie: jak mo(cid:298)na wywo(cid:225)ywa(cid:252) jak(cid:261)kolwiek
metod(cid:266) na rzecz ci(cid:261)gu znaków? Wystarczy jednak sobie przypomnie(cid:252) stwierdzenie,
które pojawi(cid:225)o si(cid:266) kilka akapitów wy(cid:298)ej, otó(cid:298) litera(cid:225)3 quit w rzeczywisto(cid:286)ci powoduje
powstanie obiektu klasy String i podstawianie w jego (litera(cid:225)u) miejsce referencji do
tego obiektu. Skoro tak, mo(cid:298)na wywo(cid:225)a(cid:252) metod(cid:266) equals. To w(cid:225)a(cid:286)nie dzi(cid:266)ki takiej kon-
strukcji unikamy wyj(cid:261)tku NullPointerException, gdy(cid:298) nawet je(cid:286)li line b(cid:266)dzie mia(cid:225)o
warto(cid:286)(cid:252) null, to metoda equals po prostu zwróci warto(cid:286)(cid:252) false, bo null na pewno jest
ró(cid:298)ne od ci(cid:261)gu znaków quit. Ostatecznie pe(cid:225)ny prawid(cid:225)owy kod b(cid:266)dzie mia(cid:225) posta(cid:252)
przedstawion(cid:261) na listingu 6.4. Przyk(cid:225)ad dzia(cid:225)ania tego kodu zosta(cid:225) 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(cid:241)czy(cid:202), 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(cid:239)(cid:200)d podczas odczytu strumienia. );
}
}
}
3 Czyli inaczej sta(cid:225)a znakowa (napisowa), sta(cid:225)y ci(cid:261)g znaków umieszczony w kodzie programu.
Kup książkęPoleć książkęRozdzia(cid:228) 6. (cid:105) System wej(cid:264)cia-wyj(cid:264)cia
277
Rysunek 6.5.
Wprowadzanie w p(cid:266)tli
kolejnych linii tekstu
Wprowadzanie liczb
Potrafimy ju(cid:298) odczytywa(cid:252) w aplikacji wiersze tekstu wprowadzane z klawiatury, równie
wa(cid:298)n(cid:261) umiej(cid:266)tno(cid:286)ci(cid:261) jest wprowadzanie liczb. Jak to zrobi(cid:252)? Trzeba sobie uzmys(cid:225)owi(cid:252), (cid:298)e
z klawiatury zawsze wprowadzany jest tekst. Je(cid:286)li próbujemy wprowadzi(cid:252) do aplika-
cji warto(cid:286)(cid:252) 123, to w rzeczywisto(cid:286)ci wprowadzimy trzy znaki, 1 , 2 i 3 o kodach
ASCII 61, 62, 63. Mog(cid:261) one zosta(cid:252) przedstawione w postaci ci(cid:261)gu 123 , ale to dopie-
ro aplikacja musi przetworzy(cid:252) ten ci(cid:261)g na warto(cid:286)(cid:252) 123. Takiej konwersji w przypadku
warto(cid:286)ci ca(cid:225)kowitej mo(cid:298)na dokona(cid:252) np. za pomoc(cid:261) metody parseInt z klasy Integer.
Jest to metoda statyczna, mo(cid:298)na j(cid:261) wi(cid:266)c wywo(cid:225)a(cid:252), nie tworz(cid:261)c obiektu klasy Integer4.
Przyk(cid:225)adowe wywo(cid:225)anie mo(cid:298)e wygl(cid:261)da(cid:252) nast(cid:266)puj(cid:261)co:
int liczba = Integer.parseInt(ci(cid:200)g_znaków);
Zmiennej liczba zostanie przypisana warto(cid:286)(cid:252) typu int zawarta w ci(cid:261)gu znaków ci(cid:200)g_
znaków. Gdyby ci(cid:261)g przekazany jako argument metody parseInt nie zawiera(cid:225) popraw-
nej warto(cid:286)ci ca(cid:225)kowitej, zosta(cid:225)by wygenerowany wyj(cid:261)tek NumberFormatException.
Aby zatem wprowadzi(cid:252) do aplikacji warto(cid:286)(cid:252) ca(cid:225)kowit(cid:261), mo(cid:298)na odczyta(cid:252) wiersz tekstu,
korzystaj(cid:261)c z metody readLine, a nast(cid:266)pnie wywo(cid:225)a(cid:252) metod(cid:266) parseInt. Ten w(cid:225)a(cid:286)nie spo-
sób zosta(cid:225) wykorzystany w programie z listingu 6.5. Zadaniem tego programu jest wczy-
tanie liczby ca(cid:225)kowitej oraz wy(cid:286)wietlenie wyniku mno(cid:298)enia tej liczby przez warto(cid:286)(cid:252) 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(cid:283) liczb(cid:218) ca(cid:239)kowit(cid:200): );
String line = null;
try{
line = brIn.readLine();
}
4 Jak wida(cid:252), metody statyczne, które by(cid:225)y przedmiotem lekcji 18., przydaj(cid:261) si(cid:266) w praktyce.
Kup książkęPoleć książkę278
Java. Praktyczny kurs
catch(IOException e){
System.out.println( B(cid:239)(cid:200)d podczas odczytu strumienia. );
return;
}
int liczba;
try{
liczba = Integer.parseInt(line);
}
catch(NumberFormatException e){
System.out.print( Podana warto(cid:258)(cid:202) nie jest liczb(cid:200) ca(cid:239)kowit(cid:200). );
return;
}
System.out.print(liczba + * 2 = + liczba * 2);
}
}
Kod zaczyna si(cid:266) od utworzenia obiektu brIn klasy BufferedReader powi(cid:261)zanego poprzez
obiekt po(cid:286)rednicz(cid:261)cy klasy InputStreamReader ze standardowym strumieniem wej(cid:286)cio-
wym. Stosujemy technik(cid:266) opisan(cid:261) przy omawianiu przyk(cid:225)adu z listingu 6.2. Nast(cid:266)pnie
wy(cid:286)wietlamy pro(cid:286)b(cid:266) o wprowadzenie liczby ca(cid:225)kowitej oraz odczytujemy wiersz tek-
stu za pomoc(cid:261) metody readLine obiektu brIn, nie zapominaj(cid:261)c o przechwyceniu ewentu-
alnego wyj(cid:261)tku IOException. W przypadku wyst(cid:261)pienia takiego wyj(cid:261)tku wy(cid:286)wietlamy sto-
sown(cid:261) informacj(cid:266) na ekranie oraz ko(cid:276)czymy wykonywanie programu. Warto zwróci(cid:252)
uwag(cid:266), (cid:298)e u(cid:298)ywana jest w tym celu instrukcja return bez (cid:298)adnych parametrów, co ozna-
cza wyj(cid:286)cie z funkcji main (bez zwracania warto(cid:286)ci), a tym samym zako(cid:276)czenie dzia-
(cid:225)ania aplikacji.
Je(cid:286)li odczyt wiersza tekstu si(cid:266) powiedzie, zostanie on zapisany w zmiennej line. Dekla-
rujemy wi(cid:266)c dalej zmienn(cid:261) liczba typu int oraz przypisujemy jej wynik dzia(cid:225)ania metody
parseInt z klasy Integer. Metodzie przekazujemy ci(cid:261)g znaków zapisany w zmiennej
line. Je(cid:286)li wprowadzony przez u(cid:298)ytkownika ci(cid:261)g znaków nie reprezentuje poprawnej
warto(cid:286)ci liczbowej, wygenerowany zostaje wyj(cid:261)tek NumberFormatException. W takim wy-
padku wy(cid:286)wietlamy komunikat o tym fakcie oraz ko(cid:276)czymy dzia(cid:225)anie funkcji main, a tym
samym programu, wywo(cid:225)uj(cid:261)c instrukcj(cid:266) return. Je(cid:286)li jednak konwersja tekstu na liczb(cid:266)
powiedzie si(cid:266), odpowiednia warto(cid:286)(cid:252) zostanie zapisana w zmiennej liczba, mo(cid:298)na za-
tem wykona(cid:252) mno(cid:298)enie liczba * 2 i wy(cid:286)wietli(cid:252) warto(cid:286)(cid:252) wynikaj(cid:261)c(cid:261) z tego mno(cid:298)enia
na ekranie. Przyk(cid:225)adowy wynik dzia(cid:225)ania programu jest widoczny na rysunku 6.6.
Rysunek 6.6.
Przyk(cid:225)adowy wynik
dzia(cid:225)ania programu
z listingu 6.5
Gdyby mia(cid:225)a by(cid:252) wczytana liczba zmiennoprzecinkowa, nale(cid:298)a(cid:225)oby do konwersji zasto-
sowa(cid:252) metod(cid:266) parseDouble z klasy Double lub parseFloat z klasy Float, co jest do-
skona(cid:225)ym (cid:252)wiczeniem do samodzielnego wykonania.
Kup książkęPoleć książkęSkorowidz
A
D
adapter MouseInputAdapter, 390
aplety, 351, 354
konstrukcja, 355
parametry, 356
tworzenie, 352
aplikacja, 351, 386
Eclipse, 6
jEdit, 6
NetBeans, 6
Notepad++, 6
argumenty
finalne, 162
konstruktorów, 111
metod, 100
ASCII, 270
B
blok
b(cid:225)(cid:261)d
default, 56
else, 48
finally, 192
switch, 55
try…catch, 165, 169–171, 180
arytmetyczny, 179
implementacji interfejsu, 234
kompilacji, 31, 39, 127, 143, 197, 256
w p(cid:266)tli while, 274
w programie, 275
bufor, 315
C
ci(cid:261)g
formatuj(cid:261)cy, 289
znaków quit, 330
czcionki, 359
deklaracja, 24
metody, 120
tablicy, 77, 80, 85
typu uogólnionego, 345
zmiennej typu klasowego, 93
deklaracje
proste, 24
wielu zmiennych, 25
dekrementacja, 35
domy(cid:286)lna strona kodowa, 293
domy(cid:286)lne warto(cid:286)ci typów danych, 99
dookre(cid:286)lanie typu, 341
dost(cid:266)p
chroniony, protected, 133
do katalogu, 298
do klasy wewn(cid:266)trznej, 253
do klasy zewn(cid:266)trznej, 245
do obiektu, 248
do sk(cid:225)adowych, 261
prywatny, private, 131
publiczny, public, 130
dynamiczna zmiana pojemno(cid:286)ci, 327
dynamiczny wektor elementów, 328
dzia(cid:225)ania arytmetyczne, 34
dzia(cid:225)anie
etykietowanej instrukcji break, 72
etykietowanej instrukcji continue, 70, 72
konstruktorów odziedziczonych, 126
operatora dekrementacji, 37
operatora inkrementacji, 36
p(cid:266)tli for, 77
przeci(cid:261)(cid:298)onej metody, 203
dziedziczenie, 121, 122
interfejsów, 235, 238
po klasie zewn(cid:266)trznej, 252
dzielenie przez zero, 173
d(cid:296)wi(cid:266)ki, 383
Kup książkęPoleć książkę418
Java. Praktyczny kurs
edytor tekstowy, 6
elementy tablic, 76
elipsa, 369
enkapsulacja, 134
etykiety, 71
puste, 405
tekstowe, 404, 405
E
F
figury geometryczne, 366
finalne
argumenty metod, 162
klasy, 156
metody, 161
pola, 157, 159
formatowanie, 290
grafika, 366
hermetyzacja, 134
hierarchia
klas, 224
wyj(cid:261)tków, 176
G
H
I
iloczyn logiczny, 43
implementacja
interfejsu, 223
interfejsu MouseListener, 401
wielu interfejsów, 230
importowanie pakietu, 271
inferowanie typu, 341
informacje
o klikni(cid:266)ciach, 379
o stanie za(cid:225)adowania obrazu, 375
inicjalizacja
obiektu, 110
pól finalnych, 160
tablicy, 80, 85
inkrementacja, 35
instalacja
JDK, 9
w systemie Linux, 11
w systemie Windows, 10
instrukcja, 23
break, 55, 66–68
continue, 68–71
if…else, 47
if…else if, 51
Math.sqrt(), 50
return, 97
switch, 53–57
System.out.print, 33, 87
System.out.println, 28
throw, 183, 190
instrukcje steruj(cid:261)ce, 47
interfejs, 222, 224
ActionListener, 393, 397
AudioClip, 383
DocumentListener, 408
Drawable, 224, 228, 229
Iterable, 333–335
Iterator, 335
jako typ zwracany, 254
MouseListener, 376–380, 385, 390, 401
MouseMotionListener, 380
WindowListener, 387
interfejsy funkcjonalne, 261, 264
J
jawna konwersja typu, 197
JDK, Java Development Kit, 6
JRE, Java Runtime Environment, 6, 10
K
katalogi, 298, 304
pobranie zawarto(cid:286)ci, 298
tworzenie, 302
usuwanie, 304
klasa, 17, 91
ActionEvent, 394, 398
Aplet, 365
Applet, 352, 383
ArrayList, 328
BufferedInputStream, 321
BufferedOutputStream, 321
BufferedReader, 272, 320
CheckBoxMenu, 398
Color, 363
Component, 403
Console, 288, 289
Dane, 118
DivideByZeroException, 190
Double, 278
Exception, 183
File, 295, 302
FileInputStream, 316
FileOutputStream, 318
FileReader, 316, 318
FileWriter, 318, 411
Font, 359
FontMetrics, 361
Kup książkęPoleć książkęSkorowidz
419
pochodne, 225
potomne, 122
prywatne, 251
publiczne, 141, 250
statyczne, 260
statyczne zagnie(cid:298)d(cid:298)one, 239, 260
wewn(cid:266)trzne, 141, 238, 240, 246, 249
wewn(cid:266)trzne lokalne, 244
zagnie(cid:298)d(cid:298)one, 254
zewn(cid:266)trzne, 241, 245
Frame, 386
GeneralException, 189
Graphics, 362, 366
GraphicsEnvironment, 360
ImageObserver, 375
InputStream, 270, 271, 272
Integer, 277
JApplet, 352, 374
JButton, 405
JCheckBox, 411
JCheckBoxMenuItem, 398, 399
JComboBox, 413, 415
JFrame, 386
JLabel, 404
JMenu, 391, 396
JMenuBar, 391
JMenuItem, 391, 392
JPopupMenu, 400
JTextArea, 410
JTextComponent, 407
JTextField, 407, 409
Main, 94
Matcher, 301
MouseEvent, 377, 382
MouseInputAdapter, 390
MouseMotionAdapter, 390
MyFilenameFilter, 300, 301
MyMouseListener, 380
MyWindowAdapter, 389
Object, 201
OutputStreamWriter, 293
Pattern, 301
Polygon, 372
PrintStream, 291
PrintWriter, 293, 294
Punkt, 93, 103
Punkt3D, 124
RandomAccessFile, 307–312
Reader, 272
RuntimeException, 176, 177
Scanner, 286–288
Shape, 208, 213
Stack, 331
StreamTokenizer, 279–286
SwingUtilities, 387
Tablica, 167
uruchomieniowa, 108
WindowAdapter, 389
klasy
abstrakcyjne, 212, 223
anonimowe, 257, 264
bazowe, 122
chronione, 251
finalne, 156
kontenerowe, 328
pakietowe, 141, 249, 250
klasyfikacja klas, 250
kod
ASCII, 270
po(cid:286)redni, 15
Unicode, 293
kodowanie, 292
kolory, 362
ko(cid:225)o, 369
komenda
java, 13
javac, 13
komentarz, 19
blokowy, 20
liniowy, 21
kompilacja, 14, 15
kompilacja wyra(cid:298)enia regularnego, 301
kompilator, 6, 15
kompilator javac, 7, 14
komponenty, 402
komunikat o b(cid:225)(cid:266)dzie, 175, 237
konflikt nazw, 232, 237, 238
koniec pliku, 314
konsola, 288
konsola systemowa, 12
konstrukcja apletu, 355
konstruktor, 110, 212
argumenty, 111
bezargumentowy, 111
domy(cid:286)lny, 93, 218
klasy bazowej, 125
klasy potomnej, 125
przeci(cid:261)(cid:298)anie, 112
wywo(cid:225)ywanie metod, 115, 219
konstruktory klasy
JCheckBox, 412
ComboBox, 413
JTextArea, 410
JTextField, 407
OutputStreamWriter, 293
kontenery, 323, 339
kontrola typów, 330, 337, 348
konwersja typów prostych, 195, 196, 199
kopiowanie plików, 312, 314, 320
kroje pisma, 358, 359
Kup książkęPoleć książkę420
Java. Praktyczny kurs
liczba, 277
linie, 368
lista czcionek, 359, 361
listy rozwijane, 413
L
M
maszyna wirtualna, 6
menu, 391
kaskadowe, 396, 397
kontekstowe, 400, 401
umo(cid:298)liwiaj(cid:261)ce zaznaczanie, 399
metoda
actionPerformed, 393, 408
actionPreformed, 395
add, 330, 392
addActionListener, 379
addMouseListener, 379, 385
addWindowListener, 387–390
clearRect, 352
createNewFile, 302
delete, 304
dispose, 390, 395
draw, 213
drawImage, 373
drawOval, 369
drawPolygon, 371
drawRectangle, 370
drawShape, 215
drawString, 386
exists, 303, 310
fillOval, 369
fillPolygon, 371
fillRectangle, 370
finalize, 118
get, 326, 343
getActionCommand, 395
getAllFonts, 360
getAudioClip, 384
getAvailableFontFamilyNames, 360
getButton, 377
getCodeBase, 372
getDocumentBase, 372
getFontMetrics, 362
getHeight, 362
getImage, 372, 373
getItem, 397
getLocalGraphicsEnvironment, 360
getMessage(), 174
getParameter, 357
getSource, 394, 399
getValues, 347
getX, 377
getY, 377
hasNext, 335
hasNextInt, 287
imageUpdate, 374
invokeLater, 387
list, 298
main, 106
mkdir, 303
mkdirs, 303
mouseClicked, 378, 380, 385
mouseDragged, 380
next, 335
nextLine, 287
nextToken, 280–282
paint, 362
parseDouble, 278
parseInt, 277
play, 385
printf, 289
read, 270, 271, 313
readLine, 272, 275
remove, 335
resize, 325, 327
save, 411
set, 325, 326
setActionCommand, 395
setBounds, 405
setColor, 362
setDocumentListener, 408
setFont, 362
setJMenuBar, 392
setLayout, 405
setSize, 386
setText, 405
show, 345, 401
size, 325
start, 286
stringWidth, 362
super, 127
System.gc, 118
toString, 202
windowClosing, 389
write, 313
metody, 95
argumenty, 100
domy(cid:286)lne, 227, 229
finalne, 161
interfejsu DocumentListener, 409
interfejsu Iterable, 334
interfejsu MouseListener, 376
interfejsu MouseMotionListener, 380
interfejsu WindowListener, 388
klasy anonimowej, 259
klasy ArrayList, 329
klasy Component, 403, 404
klasy Console, 289
klasy File, 296, 297, 298
klasy FileInputStream, 316
klasy FileOutputStream, 318
Kup książkęPoleć książkęSkorowidz
421
klasy FileReader, 317
klasy FileWriter, 318
klasy Graphics, 366
klasy InputStream, 270
klasy JComboBox, 414
klasy PrintStream, 291, 292
klasy RandomAccessFile, 307, 308
klasy Scanner, 286
klasy Stack, 331
prywatne, 210
przeci(cid:261)(cid:298)anie, 108, 144
przes(cid:225)anianie, 146
statyczne, 152, 277
wywo(cid:225)anie polimorficzne, 208, 220, 259
wywo(cid:225)ywane w konstruktorach, 115, 219
zwracanie wyniku, 97
mno(cid:298)enie liczb, 284
model RGB, 363
mysza, 376
N
narz(cid:266)dzia, 6
narz(cid:266)dzia JDK, 11
nawias
k(cid:261)towy, 343
klamrowy, 47, 95, 170
kwadratowy, 75, 80, 82
okr(cid:261)g(cid:225)y, 170, 196
nazwa
klasy, 92
pakietu, 138
pliku, 92
zmiennych, 26
negacja logiczna, 43
nieprawid(cid:225)owa implementacja interfejsów, 234
niew(cid:225)a(cid:286)ciwy typ danych, 340, 344
niszczenie obiektu, 121
O
obiekt, 17, 94
file, 298
InputStreamReader, 272
jako argument, 102
klasy wewn(cid:266)trznej, 246, 249
klasy zewn(cid:266)trznej, 249
outp, 294
strTok, 284
System.in, 269, 272, 287
obs(cid:225)uga
d(cid:296)wi(cid:266)ków, 383
konsoli, 288
menu, 391, 394
myszy, 376
okna, 390
przycisków, 405
zdarze(cid:276), 389, 394, 397
odczyt danych z pliku, 309
odniesienie, 27
od(cid:286)miecacz, 120
odtwarzanie d(cid:296)wi(cid:266)ków, 383
odwo(cid:225)anie
do nieistniej(cid:261)cego elementu, 166
do prywatnego pola, 246
do pustej zmiennej obiektowej, 179
odzyskiwanie pami(cid:266)ci, 118
okno wyboru sk(cid:225)adników JDK, 10
opcja encoding, 31, 293
operacje
na plikach, 306
na tablicach, 74
na zmiennych, 33
operator
+, 28
dekrementacji, 35
inkrementacji, 35
kropki, 94
new, 81, 85, 93
warunkowy, 57
operatory
arytmetyczne, 34
bitowe, 41, 42
logiczne, 42, 43
porównywania, 44, 45
przypisania, 44
P
pakiet, 137, 250
java.awt, 352, 358
java.io, 271
java.util, 328
javax.swing, 352, 402
JDK, 6
parametr
mode, 308
this, 388
parametry
apletu, 356
zdarzenia, 381
pasek menu, 391
p(cid:266)tla, 59
do…while, 63, 64
for, 59–61
foreach, 65, 333
while, 62, 63, 273
p(cid:266)tle zagnie(cid:298)d(cid:298)one, 70, 82
pierwiastki równania kwadratowego, 284
plik, 304
index.html, 354
Main.class, 15
Main.java, 14, 95
Kup książkęPoleć książkę422
Java. Praktyczny kurs
pliki
d(cid:296)wi(cid:266)kowe, 383
kopiowanie, 312, 314, 320
odczyt danych, 309, 316
o dost(cid:266)pie swobodnym, 307
operacje strumieniowe, 316
tworzenie, 302
usuwanie, 304
zapis danych, 310, 318
pobranie
tokena, 281
zawarto(cid:286)ci katalogu, 298
pola, 91, 149
finalne, 157
finalne typów prostych, 158
finalne typów referencyjnych, 159
interfejsów, 226
JCheckBox, 411
niezainicjowane, 98
statyczne, 153
tekstowe, 407, 408
pole
polecenie
nval, 281
sval, 281
ttype, 280
chcp, 30
cmd, 12
import, 138
javac, 14
polimorficzne wywo(cid:225)ywanie metod, 208, 220, 259
polimorfizm, 195, 206
polskie znaki, 292
ponowne zg(cid:225)aszanie wyj(cid:261)tków, 187
poprawno(cid:286)(cid:252) danych, 165
pó(cid:296)ne wi(cid:261)zanie, 204, 206
praklasa, 202
priorytety operatorów, 45
problem kontroli typów, 337
programowanie obiektowe, 91, 195
przechowywanie wielu danych, 323
przechwytywanie wielu wyj(cid:261)tków, 177
przeci(cid:261)(cid:298)anie
konstruktorów, 112
metod, 108
przegl(cid:261)danie kontenerów, 333
przekroczenie zakresu warto(cid:286)ci, 41
przes(cid:225)anianie
metod, 144–149
pól, 146, 149, 151
przyciski, 405
przypisanie, 24
punkty, 368
R
referencja, reference, 27
referencje do obiektu, 102, 114, 207
reprezentacja liczb, 42
RGB, 363
rodzaje
klas wewn(cid:266)trznych, 246, 249
pól tekstowych, 407
wyj(cid:261)tków, 173
rodziny czcionek, 361
rozmiar tablicy, 78, 326
równanie kwadratowe, 50, 284, 286
rysowanie
elips, 369
figur, 366
kó(cid:225), 369
linii, 368
prostok(cid:261)tów, 368, 370
punktów, 368
wielok(cid:261)tów, 370, 371
rzeczywisty typ obiektu, 204
rzutowanie
na interfejs, 256
na typ Object, 201
na typy interfejsowe, 254
na typy klasowe, 257
obiektów, 195
typów obiektowych, 128, 197, 201, 341
w gór(cid:266), 206
S
sekcja finally, 190
sekwencja ucieczki, 32
sekwencje znaków specjalnych, 32
sk(cid:225)adnia
ExtendedOutside.Inside, 253
Outside.Inside, 253
sk(cid:225)adowe
klas wewn(cid:266)trznych, 242
klasy, 92
RGB, 364
statyczne, 152
skrypt startowy pow(cid:225)oki, 13
s(cid:225)owo kluczowe
else, 47
extends, 235
final, 156
implements, 226
package, 137
super, 211
this, 114, 116
void, 96, 100
Kup książkęPoleć książkęSkorowidz
423
specyfikator dost(cid:266)pu, 129
private, 131
protected, 133
public, 130
sprawdzanie poprawno(cid:286)ci danych, 165
sta(cid:225)a
EXIT_ON_CLOSE, 387
napisowa, 276
sta(cid:225)e klasy
Color, 363
MouseEvent, 382
stan zmiennej iteracyjnej, 60
standard
CP1250, 292
CP852, 293
Unicode, 30, 293
standardowe
wej(cid:286)cie, 269
wyj(cid:286)cie, 279
statyczno(cid:286)(cid:252) klasy wewn(cid:266)trznej, 260
sterta, heap, 94
stos, stack, 94
stosowanie uogólnie(cid:276), 341
strona kodowa, 293
strona kodowa 1250, 30
struktura
programu, 13
tablicy, 74
tablicy dwuwymiarowej, 80
strumieniowe operacje na plikach, 316
strumie(cid:276) wej(cid:286)ciowy, 269
suma logiczna, 43
symbol T, 343
system plików, 295
system wej(cid:286)cia-wyj(cid:286)cia, 269
(cid:263)
(cid:286)cie(cid:298)ka dost(cid:266)pu do katalogu, 298
(cid:286)rednik, 258
(cid:286)rodowisko
programistyczne, 6
uruchomieniowe, 7, 10
T
tablice, 74
dwuwymiarowe, 80
dynamiczne, 326, 328
nieregularne, 84, 89
tekst, 271
terminal, 12
testowanie apletów, 354
tokeny, 279, 280
tworzenie
apletu, 352
aplikacji, 386
etykiet, 405
interfejsów, 222
katalogów, 302
klas wewn(cid:266)trznych, 239
klasy anonimowej, 257–259
list rozwijalnych, 413
menu, 392
nieregularnej tablicy dwuwymiarowej, 86
obiektów, 105
obiektów klas wewn(cid:266)trznych, 248
obiektu, 96, 98
obiektu strTok, 281
obiektu wyj(cid:261)tku, 183
pakietów, 137
paska menu, 394
plików, 302
tablicy, 80, 82
wielu klas wewn(cid:266)trznych, 240
w(cid:225)asnych wyj(cid:261)tków, 188
tymczasowa zmienna referencyjna, 395
typ
boolean, 19
byte, 18
char, 19
double, 19
float, 19
int, 18
long, 18
Object, 201
short, 18
typy
arytmetyczne ca(cid:225)kowitoliczbowe, 18
arytmetyczne zmiennopozycyjne, 19
danych, 16
generyczne, 336
obiektowe, 26, 197
proste, primitive types, 18
uogólnione, 336
U
Unicode, 293
uogólnianie metod, 345
uogólnienia, 341
uruchamianie apletu, 354
usuwanie
katalogów, 304
komentarzy, 256
plików, 304
W
warto(cid:286)ci
domy(cid:286)lne pól, 98
parametru mode, 308
pola ttype, 280
Kup książkęPoleć książkę424
Java. Praktyczny kurs
wywo(cid:225)ania
konstruktorów, 216
metod, 115, 219
metod klas pochodnych, 204
metod klasy wewn(cid:266)trznej, 247
metod nieistniej(cid:261)cych, 225
metod przes(cid:225)oni(cid:266)tych, 147
z(cid:225)o(cid:298)one konstruktorów, 219
Z
zagnie(cid:298)d(cid:298)anie bloków try…catch, 180, 186
zako(cid:276)czenie dzia(cid:225)ania programu, 274
zakres
warto(cid:286)ci zmiennej, 40
typów arytmetycznych, 18
typów zmiennoprzecinkowych, 19
zapis do pliku, 310, 318
zaznaczanie pozycji, 399
zdarzenia
myszy, 377
zwi(cid:261)zane z oknem, 387
zg(cid:225)aszanie
wyj(cid:261)tku, 182
ponowne wyj(cid:261)tku, 185
zmiana
czcionki, 31
strony kodowej, 30
zmienna (cid:286)rodowiskowa
CLASSPATH, 139, 140
PATH, 13
zmienne, 23, 102
referencyjne, 94
typów odno(cid:286)nikowych, 26
znacznik
applet , 353
object , 353
znaczniki formatuj(cid:261)ce printf, 290
znak , 289
znaki
polskie, 29
specjalne, 32
zwracanie
wielu warto(cid:286)ci, 346
wyniku, 97
warto(cid:286)(cid:252)
aktualnego tokena, 280
null, 27, 120, 275
warunek zako(cid:276)czenia p(cid:266)tli, 274
wbudowane typy danych, 18
wczesne wi(cid:261)zanie, 208
wczytywanie
danych, 277, 283, 286, 288
grafiki, 372
tekstu, 271, 273, 277
wersje Javy, 7
wi(cid:261)zanie
czasu wykonania, 206
dynamiczne, 206
wielok(cid:261)ty, 370
wiersz
polece(cid:276), 12
tekstu, 273
wirtualna maszyna Javy, 15
w(cid:225)a(cid:286)ciwo(cid:286)(cid:252) length, 78, 83
wprowadzanie, Patrz wczytywanie
wspó(cid:225)rz(cid:266)dne
biegunowe, 134
klikni(cid:266)cia, 380
wybór sk(cid:225)adników JDK, 10
wyj(cid:261)tek, exception, 165, 169
ArithmeticException, 175, 179, 181
ArrayIndexOutOfBoundsException, 76, 165,
169, 324
ClassCastException, 205, 206, 337
DivideByZeroException, 189
FileNotFoundException, 308, 310
IOException, 271, 303
NullPointerException, 179, 181, 276
NumberFormatException, 277, 278, 365
PatternSyntaxException, 300
UnsupportedEncodingException, 293, 294
UnsupportedOperationException, 335
wyj(cid:261)tki w(cid:225)asne, 182, 188
wykonanie programu, 15
wykorzystanie
kontenerów, 339
obiektów, 140
pakietów, 139
wyra(cid:298)enia
lambda, 266
regularne, 299–302
wy(cid:286)wietlanie
elementów tablicy nieregularnej, 87
menu, 401
napisu, 386
polskich znaków, 294
przycisków, 405
systemowego komunikatu, 175
warto(cid:286)ci zmiennych, 27
zawarto(cid:286)ci katalogu, 299
zawarto(cid:286)ci tablicy, 81
Kup książkęPoleć książkę
Pobierz darmowy fragment (pdf)