Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00245 009235 17294667 na godz. na dobę w sumie
Java. Praktyczny kurs. Wydanie IV - ebook/pdf
Java. Praktyczny kurs. Wydanie IV - ebook/pdf
Autor: Liczba stron: 424
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-0925-8 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook, audiobook).

To Java, nie sen!

Znajomość Javy, jako jednego z najpopularniejszych języków programowania na świecie, to dziś obowiązek każdego programisty. Na nic nie zdadzą się wykręty, że przecież można inaczej — pamiętaj, Java jest wszędzie! Dlatego jeśli masz ambicje zająć się programowaniem albo szybko nauczyć się podstaw nowego języka, natychmiast musisz zaopatrzyć się w tę książkę. Pomoże Ci ona zrozumieć składnię i logikę Javy, a także opanować polecenia, byś mógł szybko rozpocząć samodzielną pracę w tym języku.

Z książki dowiesz się, jak zainstalować Javę i jakie narzędzia będą Ci potrzebne. Odkryjesz podstawowe zasady pisania programów, z uwzględnieniem obiektowego charakteru tego języka, nauczysz się stosować instrukcje i odpowiednie typy danych, a także wykorzystywać deklaracje, klasy i metody. Kolejne rozdziały wskażą Ci, do czego służą pętle, tablice i operatory. Zanim się obejrzysz, będziesz już umiał dokonywać konwersji typów, używać konstruktorów i zagnieżdżać klasy, a stąd już tylko krok do tworzenia apletów i aplikacji. Przekonaj się, jak szybko możesz poznać Javę — wystarczy seria konkretnych ćwiczeń, a Twoje umiejętności poszybują w górę! Napisz swój pierwszy program w Javie!
Znajdź podobne książki Ostatnio czytane w tej kategorii

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)

Gdzie kupić całą publikację:

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