Java jest jednym z najpopularniejszych języków programowania na świecie wykorzystywanym przy tworzeniu popularnych aplikacji. Język ten dla początkujących programistów jest często pierwszym poznanym językiem programowania. Dzięki przemyślanej architekturze obiektowej Javy łatwiej Ci będzie nabrać prawidłowych nawyków programistycznych, z kolei funkcjonalność tego języka sprawi, że nauka nie pójdzie na marne, a zdobytą wiedzę wykorzystasz w praktyce. W Javie można bowiem napisać prawie każdą aplikację, od prostej gry działającej w telefonie komórkowym, po skomplikowany system uruchamiany na potężnym serwerze. "Po prostu Java 2" to książka, dzięki której nauczysz się pisać programy w tym języku, nawet jeśli programowanie było Ci do tej pory zupełnie obce. Książka jest pozbawiona zbędnego balastu teorii. Prezentuje ona wiele zastosowań Javy. Dzięki książce nauczysz się: * Składni Javy oraz podstawowych instrukcji * Korzystać z obiektów i rozpoznawać ich metody * Tworzyć interfejs użytkownika dla aplikacji Javy * Pisać aplety i osadzać je w stronach WWW * Łączyć Javę z JavaScript * Pisać servlety i strony JSP * Korzystać z XML z poziomu Javy Chcesz szybko i bez zbędnych dywagacji dowiedzieć się, dlaczego Java cieszy się takim powodzeniem? Chcesz wykorzystać ją do swoich potrzeb? Ta książka z pewnością Ci w tym pomoże.

1. IDZ DO
PRZYK£ADOWY ROZDZIA£
SPIS TRE CI Po prostu Java 2
KATALOG KSI¥¯EK
Autor: Dori Smith
KATALOG ONLINE T³umaczenie: Miko³aj Szczepaniak
ISBN: 83-7197-686-0
ZAMÓW DRUKOWANY KATALOG Tytu³ orygina³u: Java 2 for the World Wide Web VQG
Format: B5, stron: 356
TWÓJ KOSZYK
DODAJ DO KOSZYKA Java jest jednym z najpopularniejszych jêzyków programowania na wiecie
wykorzystywanym przy tworzeniu popularnych aplikacji. Jêzyk ten dla pocz¹tkuj¹cych
programistów jest czêsto pierwszym poznanym jêzykiem programowania. Dziêki
CENNIK I INFORMACJE przemy lanej architekturze obiektowej Javy ³atwiej Ci bêdzie nabraæ prawid³owych
nawyków programistycznych, z kolei funkcjonalno æ tego jêzyka sprawi, ¿e nauka nie
ZAMÓW INFORMACJE pójdzie na marne, a zdobyt¹ wiedzê wykorzystasz w praktyce. W Javie mo¿na bowiem
O NOWO CIACH napisaæ prawie ka¿d¹ aplikacjê, od prostej gry dzia³aj¹cej w telefonie komórkowym,
po skomplikowany system uruchamiany na potê¿nym serwerze.
ZAMÓW CENNIK „Po prostu Java 2” to ksi¹¿ka, dziêki której nauczysz siê pisaæ programy w tym jêzyku,
nawet je li programowanie by³o Ci do tej pory zupe³nie obce. Ksi¹¿ka jest pozbawiona
zbêdnego balastu teorii. Prezentuje ona wiele zastosowañ Javy.
CZYTELNIA Dziêki ksi¹¿ce nauczysz siê:
FRAGMENTY KSI¥¯EK ONLINE • Sk³adni Javy oraz podstawowych instrukcji
• Korzystaæ z obiektów i rozpoznawaæ ich metody
• Tworzyæ interfejs u¿ytkownika dla aplikacji Javy
• Pisaæ aplety i osadzaæ je w stronach WWW
• £¹czyæ Javê z JavaScript
• Pisaæ servlety i strony JSP
• Korzystaæ z XML z poziomu Javy
Chcesz szybko i bez zbêdnych dywagacji dowiedzieæ siê, dlaczego Java cieszy siê
takim powodzeniem? Chcesz wykorzystaæ j¹ do swoich potrzeb? Ta ksi¹¿ka
z pewno ci¹ Ci w tym pomo¿e.
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl

2. Spis treści
Spis treści
Wstęp 11
Rozdział 1. Czym jest Java? 17
Krótka lekcja historii................................................................................. 18
Dlaczego uczyć się Javy?.......................................................................... 20
Rozpowszechnione mity o Javie ............................................................... 21
Co będzie Ci potrzebne............................................................................. 24
Wersje Javy............................................................................................... 25
Rozdział 2. Podstawy Javy 27
Wprowadzenie w niesamowity świat Wirtualnej Maszyny Javy.............. 28
Bezpieczeństwo Javy ................................................................................ 29
Spis treści
Pliki Javy................................................................................................... 30
Gra w Buzzword Bingo ............................................................................ 31
Rozdział 3. Używanie Javy na stronach WWW 37
Znacznik APPLET .................................................................................... 38
Znacznik OBJECT .................................................................................... 40
Znacznik OBJECT połączony ze znacznikiem EMBED .......................... 43
Wyświetlanie komunikatów w przeglądarkach nie obsługujących Javy .. 45
Ustawianie poło enia apletów Javy na stronach WWW........................... 47
Znajdowanie apletów w Internecie ........................................................... 49
Przekazywanie parametrów do apletu....................................................... 51
Rozdział 4. Twoje pierwsze aplety 55
„Witaj świecie!”........................................................................................ 56
Posługiwanie się czcionkami .................................................................... 58
Ustawianie koloru tła ................................................................................ 59
Przekazywanie parametrów z pliku HTML do apletu Javy ...................... 60
Dodawanie komentarzy ............................................................................ 62
Zmiana stylu czcionki ............................................................................... 63
Zmiana kolorów ........................................................................................ 64
5

3. Spis treści
Rozdział 5. Łańcuchy 65
Zmienne łańcuchowe ................................................................................ 66
Więcej o łańcuchach ................................................................................. 68
Zasięg deklaracji zmiennych..................................................................... 70
Metody klasy String.................................................................................. 72
Wszystkie typy liczbowe .......................................................................... 74
Wzajemne przekształcanie łańcuchów i liczb........................................... 77
Przekształcenia typów liczbowych ........................................................... 79
Przekształcanie przez rzutowanie ............................................................. 81
Tablice obiektów....................................................................................... 83
Rozdział 6. Podejmowanie decyzji 85
Instrukcje warunkowe — if ...................................................................... 86
Przechwytywanie błędów ......................................................................... 89
Więcej o instrukcjach warunkowych — if…else ..................................... 93
Powtarzanie czynności za pomocą pętli.................................................... 96
Inny rodzaj pętli — while ......................................................................... 98
Spis treści
Ostatni rodzaj pętli — do…while ........................................................... 100
Przerywanie działania pętli ..................................................................... 102
Konstrukcja switch…case....................................................................... 104
Rozdział 7. Współpraca z użytkownikiem 109
Rysowanie za pomocą myszy ................................................................. 110
Rysowanie w dwóch wymiarach ............................................................ 113
Swobodne rysowanie .............................................................................. 116
Przechwytywanie naciskania klawiszy ................................................... 118
Przemieszczanie obrazów ....................................................................... 120
U ywanie klawiszy modyfikujących ...................................................... 122
Rozdział 8. Budowa interfejsu użytkownika 125
Strony chronione hasłem......................................................................... 126
Wpisywanie i wyświetlanie tekstu.......................................................... 129
Praca z polami wyboru............................................................................ 131
U ywanie przycisków opcji .................................................................... 134
Elementy rozwijanego menu................................................................... 137
Ustawianie menu czcionki w Javie ......................................................... 139
U ywanie wieloliniowych pól tekstowych ............................................. 141
U ywanie list przewijanych .................................................................... 144
6

4. Spis treści
Rozdział 9. Rozmieszczanie elementów interfejsu użytkownika 147
Brak rozmieszczenia — FlowLayout...................................................... 148
U ywanie menad era FlowLayout.......................................................... 150
Wstawianie wolnych przestrzeni w obszarze apletu............................... 152
U ywanie menad era BorderLayout....................................................... 154
U ywanie menad era GridLayout .......................................................... 156
U ywanie wkładek.................................................................................. 158
Dodawanie komponentów z wykorzystaniem paneli.............................. 160
U ywanie menad era CardLayout .......................................................... 162
U ywanie menad era GridBagLayout .................................................... 165
Rozdział 10. Manipulowanie obrazami i animacje 169
Wyświetlanie obrazu............................................................................... 170
Wyświetlanie fragmentu obrazu ............................................................. 172
Rysowanie ramki wokół apletu............................................................... 174
Wyświetlanie wielu obrazów .................................................................. 176
Wątki i animacja ..................................................................................... 179
Spis treści
Podwójnie buforowane animacje ............................................................ 183
Wyświetlanie nieskończonej liczby obrazów ......................................... 186
Kontrola animacji.................................................................................... 188
Rozdział 11. Java i JavaScript 191
Sprawdzanie obsługi Javy przez przeglądarkę........................................ 192
JavaScript i publiczne metody Javy ........................................................ 194
Przekazywanie danych z JavaScriptu do Javy ........................................ 197
Przekazywanie danych z Javy do JavaScriptu ........................................ 200
Rozdział 12. Projektowanie interfejsu użytkownika z komponentami Swing 203
Twój pierwszy aplet wykorzystujący komponent Swing........................ 204
Ustawianie czcionek dla komponentów Swing ...................................... 206
Pola wyboru Swing ................................................................................. 208
Przyciski opcji Swing ............................................................................. 211
Wygląd apletu zgodny z preferencjami u ytkownika............................. 214
Animacja i Swing.................................................................................... 219
Swing w akcji.......................................................................................... 223
7

5. Spis treści
Rozdział 13. JavaServer Pages i Serwlety Javy 231
Twoja pierwsza strona JSP ..................................................................... 232
JSP i formularze...................................................................................... 234
Instrukcje warunkowe w JSP .................................................................. 236
Zapisywanie cookies za pomocą JSP...................................................... 238
Odczytywanie cookies za pomocą JSP ................................................... 240
XML i JSP .............................................................................................. 243
Twój pierwszy serwlet ............................................................................ 245
Ankieta i serwlety ................................................................................... 248
Rozdział 14. Java i narzędzia wizualne 257
Wstawianie znacznika applet w programie Dreamweaver ..................... 258
Wstawianie znacznika object w programie Dreamweaver ..................... 261
Wstawianie znacznika applet w programie GoLive ............................... 263
Wstawianie znacznika object w programie GoLive ............................... 265
Rozdział 15. Kółko i krzyżyk 267
Gra w kółko i krzy yk............................................................................. 268
Spis treści
Rozdział 16. Prosty kalkulator 283
Aplet z prostym kalkulatorem................................................................. 284
Rozdział 17. Prawdziwy świat Javy — hierarchiczne menu 291
Java i hierarchiczne menu ....................................................................... 292
Dodatek A Gdzie szukać dodatkowych informacji? 307
Java w Internecie..................................................................................... 308
Czasopisma internetowe ......................................................................... 311
Zintegrowane środowiska oprogramowania ........................................... 312
Ksią ki o Javie ........................................................................................ 314
Grupy dyskusyjne ................................................................................... 316
Witryny internetowe a przenośność Javy................................................ 317
Dodatek B Zarezerwowane słowa kluczowe 319
Zarezerwowane słowa kluczowe Javy .................................................... 320
Dodatek C Hierarchia obiektów Javy 323
Pakiet java.applet .................................................................................... 324
Pakiet java.awt ....................................................................................... 324
Pakiet java.awt.color (wprowadzony w JDK 1.2) .................................. 325
Pakiet java.awt.datatransfer (wprowadzony w JDK 1.1)........................ 326
8

6. Spis treści
Pakiet java.awt.dnd (wprowadzony w JDK 1.2)..................................... 326
Pakiet java.awt.event (wprowadzony w JDK 1.1) .................................. 327
Pakiet java.awt.font (wprowadzony w JDK 1.2) .................................... 327
Pakiet java.awt.geom (wprowadzony w JDK 1.2).................................. 328
Pakiet java.awt.im (wprowadzony w JDK 1.2) ...................................... 328
Pakiet java.awt.image (wprowadzony w JDK 1.2) ................................. 329
Pakiet java.awt.image.renderable (wprowadzony w JDK 1.2) ............... 330
Pakiet java.awt.peer (od wersji JDK 1.1, nie powinno się
bezpośrednio u ywać interfejsów tego pakietu) ..................................... 330
Pakiet java.awt.print (wprowadzony w JDK 1.2) ................................... 331
Pakiet java.beans (wprowadzony w JDK 1.1) ........................................ 331
Pakiet java.beans.beancontext (wprowadzony w JDK 1.2) .................... 332
Pakiet java.io........................................................................................... 333
Pakiet java.lang ...................................................................................... 334
Pakiet java.lang.ref (wprowadzony w JDK 1.2) ..................................... 335
Pakiet java.lang.reflect (wprowadzony w JDK 1.1) ............................... 335
Pakiet java.math (wprowadzony w JDK 1.1) ......................................... 336
Spis treści
Pakiet java.net ......................................................................................... 336
Pakiet java.text (wprowadzony w JDK 1.1) ........................................... 336
Pakiet java.util ........................................................................................ 337
Pakiet java.util.jar (wprowadzony w JDK 1.2) ....................................... 337
Pakiet java.util.zip (wprowadzony w JDK 1.1) ...................................... 338
Dodatek D Różnice pomiędzy JDK 1.0, 1.1, 1.2 i 1.3 339
„Stary” model zdarzeń ............................................................................ 340
Skorowidz 347
9

7. Podejmowanie decyzji
Podejmowanie decyzji
Podejmowanie decyzji
Nie zawsze aplety Javy przechodzą najprostszą
drogę od pierwszej do ostatniej instrukcji.
Niekiedy potrzebne jest ominięcie fragmentu
kodu, czy te powtórne uruchomienie pewnych
instrukcji. Wpływanie na przebieg działania
programu nazywa się sterowaniem przepływem
(ang. flow control). W tym rozdziale omówimy,
jak zapanować nad kierunkiem przetwarzania
Twojego kodu.
Podejmowanie decyzji
85

8. Rozdział 6.
Listing HTML 6.1. Umieszcza aplet 6.1 w oknie
Instrukcje warunkowe — if przeglądarki
Najprostszym sposobem przejęcie kontroli
nad działaniem apletu jest u ycie instrukcji KH. JVON
Działanie tej instrukcji mo na wyrazić słowami: JGCF
„Jeśli (KH) jakaś wartość jest prawdziwa (VTWG), VKVNG .KUVKPI VKVNG
wówczas uruchom instrukcje znajdujące się JGCF
DQF[ DIEQNQT YJKVG
w nawiasach klamrowych. W przeciwnym QDLGEV ENCUUKF ENUKF#%'
wypadku pomiń ten fragment kodu”. Listing å$'( YKFVJ JGKIJV
HTML 6.1 i aplet 6.1 pokazują, jak u ywać åEQFGV[RG CRRNKECVKQPLCXC
instrukcji warunkowych w celu wyświetlenia RCTCO PCOG EQFG XCNWG #RRNGVENCUU
wpisanego przez u ytkownika tekstu. RCTCO PCOG V[RG XCNWG CRRNKECVKQP
åZLCXCCRRNGVXGTUKQP
RCTCO PCOG UETKRVCDNG XCNWG HCNUG
Aby skorzystać z instrukcji if, GODGF V[RG CRRNKECVKQPZLCXCCRRNGV
należy wpisać: åXGTUKQP EQFG #RRNGVENCUU YKFVJ
å JGKIJV UETKRVCDNG HCNUG
1. KORQTV LCXCCYVGXGPV

9. åRNWIKPURCIG JVVRLCXCUWPEQORTQFWEVU
åRNWIKPRNWIKPKPUVCNNJVON
Na początku musimy obsłu yć zdarzenia GODGF
Instrukcje warunkowe — if
generowane przez u ytkownika. Konieczne QDLGEV
do tego będą klasy z pakietu LCXCCYVGXGPV, DQF[
które w tym kroku importujemy. JVON
2. RWDNKE ENCUU #RRNGV GZVGPFU #RRNGV
Aplet 6.1. Jeśli wpiszesz tekst do pola inField, Java
åKORNGOGPVU #EVKQP.KUVGPGT ] wyświetli go na ekranie
Nasza nowa klasa (nazwana #RRNGV) została
zdefiniowana jako rozszerzenia standardowej KORQTV LCXCCYV

10. klasy #RRNGV. Nowością w tej definicji jest KORQTV LCXCCRRNGV#RRNGV
słowo kluczowe KORNGOGPVU #EVKQP.KUVGPGT. KORQTV LCXCCYVGXGPV

11. Oznacza to, e nasz aplet będzie zdolny
do obsługi zdarzeń generowanych przez RWDNKE ENCUU #RRNGV GZVGPFU #RRNGV KORNGOGPVU
å#EVKQP.KUVGPGT ]
u ytkownika i będzie przez cały czas swojego 6GZV(KGNF KP(KGNF PGY 6GZV(KGNF
działania oczekiwał na jego konkretne (QPV H PGY (QPV
6KOGU4QOCP (QPV$1.
czynności. Tabela 6.1 przedstawia metody 5VTKPI YRKUCP[6GMUV
słu ące do przechwytywania interakcji
z u ytkownikiem dla poszczególnych RWDNKE XQKF KPKV
]
elementów. UGV$CEMITQWPF
%QNQTYJKVG
KP(KGNFCFF#EVKQP.KUVGPGT
VJKU
3. 6GZV(KGNF KP(KGNF PGY 6GZV(KGNF
CFF
KP(KGNF
(QPV H PGY (QPV
6KOGU4QOCP (QPV _
å$1.
5VTKPI YRKUCP[6GMUV RWDNKE XQKF RCKPV
)TCRJKEU I ]
IUGV(QPV
H
Oto, jak tworzymy nowe zmienne: KH
YRKUCP[6GMUV ]
pole tekstowe KP(KGNF, przeznaczone IFTCY5VTKPI
9RKUC G
YRKUCP[6GMUV
å
do wpisywania znaków przez u ytkownika,
_
zmienną czcionki H, którą ustawiamy _
na rozmiar 24-punktowy i pogrubiony krój
Times Roman, oraz łańcuch YRKUCP[6GMUV, RWDNKE XQKF CEVKQP2GTHQTOGF
#EVKQP'XGPV G ]
który będzie zawierał tekst wpisany przez YRKUCP[6GMUV KP(KGNFIGV6GZV
u ytkownika i wypisywany później na ekranie TGRCKPV
_
(na początku ustawiamy łańcuch jako pusty). _
86

12. Podejmowanie decyzji
4. KP(KGNFCFF#EVKQP.KUVGPGT
VJKU
CFF
KP(KGNF
Teraz wstawiamy dwie nowe instrukcje
metodzie KPKV
. Pierwsza określa, e
chcemy u yć interfejsu #EVKQP.KUVGPGT
(omówionego w kroku 2.), by przechwytywać
działania u ytkownika w polu tekstowym
KP(KGNF. Dzięki temu, za ka dym razem,
kiedy u ytkownika cokolwiek wpisze
w tym polu, wyzwolone będzie
Rysunek 6.1. Oto aplet wyświetlający wpisany odpowiednie zdarzenie w Javie (ang. event).
przez u ytkownika tekst Druga linia spowoduje wyświetlenie pola
tekstowego w obszarze apletu.
5. KH
YRKUCP[6GMUV ]
IFTCY5VTKPI
9RKUC G
åYRKUCP[6GMUV
_
Instrukcje warunkowe — if
Wtedy, i tylko wtedy, gdy łańcuch
YRKUCP[6GMUV zawiera jakikolwiek znak
(długość łańcucha jest większa od zera),
wyświetlamy tekst wpisany przez
u ytkownika. Jeśli łańcuch jest pusty,
instrukcja IFTCY5VTKPI
nie zostanie
wykonana.
Wskazówki 6. RWDNKE XQKF CEVKQP2GTHQTOGF
å
#EVKQP'XGPV G ]
Jeśli programowałeś wcześniej w innych YRKUCP[6GMUV KP(KGNFIGV6GZV
językach, mo esz sądzić, e konieczne TGRCKPV
jest u ycie instrukcji VJGP po instrukcji KH. _
W Javie nie u ywa się tej instrukcji.
Poniewa dodaliśmy wcześniej
Bardzo często w programach Javy mo na #EVKQP.KUVGPGT do pola tekstowego
spotkać instrukcję KH poprzedzającą KP(KGNF, metoda CEVKQP2GTHQTOGF
pojedynczą, wciętą instrukcję będzie obsługiwać wszystkie zdarzenia
nie umieszczoną w nawiasach wywołane przez u ytkownika. Jedynym
klamrowych. Taka poprawna składnia mo liwym zdarzeniem w tym aplecie jest
oznacza, e instrukcja warunkowa KH wpisanie tekstu w jedynym polu tekstowym.
dotyczy tylko jednej, następującej po niej Kiedy to się stanie, przypisujemy zmiennej
instrukcji. Dla zachowania przejrzystości łańcuchowej YRKUCP[6GMUV dane z tego pola.
kodu, w ksią ce tej zawsze będziemy Następnie wywołujemy metodę TGRCKPV
,
następujące po KH instrukcje umieszczać która odświe a obszar apletu (efekt
w nawiasach klamrowych. mo emy zobaczyć na rysunku 6.1).
87

13. Rozdział 6.
Tabela 6.1. Zdarzenia w Javie
Interfejs Komponenty Metody
#EVKQP.KUVGPGT $WVVQP (przycisk) #EVKQP2GTHQTOGF
.KUV (lista)
6GZV(KGNF (pole tekstowe)
/GPW+VGO (element menu)
#FLWUVOGPV.KUVGPGT 5ETQNNDCT (pasek przewijania) CFLWUVOGPV8CNWG%JCPIGF
%QORQPGPV.KUVGPGT Wszystkie komponenty EQORQPGPV*KFFGP
%QORQPGPV/QXGF
EQORQPGPV4GUKGF
EQORQPGPV5JQYP
%QPVCKPGT.KUVGPGT Wszystkie pojemniki EQORQPGPV#FFGF
EQORQPGPV4GOQXGF
(QEWU.KUVGPGT Wszystkie komponenty HQEWU)CKPGF
HQEWU.QUV
+VGO.KUVGPGT %JGEMDQZ (pole wyboru) KVGO5VCVG%JCPIGF
Instrukcje warunkowe — if
%JGEM$QZ/GPW+VGO (pole wyboru elementu menu)
%JQKEG (lista rozwijana)
+VGO5GNGEVCDNG (element mo liwy do wybrania)
.KUV (lista)
-G[.KUVGPGT Wszystkie komponenty MG[2TGUUGF
MG[4GNGCUGF
MG[6[RGF
/QWUG.KUVGPGT Wszystkie komponenty OQWUG%NKEMGF
OQWUG'PVGTGF
OQWUG'ZKVGF
OQWUG2TGUUGF
OQWUG4GNGCUGF
/QWUG/QVKQP.KUVGPGT Wszystkie komponenty OQWUGTCIIGF
OQWUG/QXGF
6GZV.KUVGPGT 6GZV%QORQPGPV (komponent tekstowy) VGZV8CNWG%JCPIGF
9KPFQY.KUVGPGT 9KPFQY (okno) YKPFQY#EVKXCVGF
YKPFQY%NQUGF
YKPFQY%NQUKPI
YKPFQYGCEVKXCVGF
YKPFQYGKEQPKHKGF
YKPFQY+EQPKHKGF
YKPFQY1RGPGF
88

14. Podejmowanie decyzji
Listing HTML 6.2. Wywołuje aplet 6.2 i umieszcza
go w oknie przeglądarki internetowej Przechwytywanie błędów
Kiedy umo liwiasz u ytkownikowi interakcję
JVON z Twoim apletem, mo e się zdarzyć, e dane,
JGCF które poda, nie będą pasowały do zało eń
VKVNG .KUVKPI VKVNG Twojego programu. Listing HTML 6.2 i aplet
JGCF 6.2 pokazują, jak przechwycić potencjalne
DQF[ DIEQNQT YJKVG
QDLGEV ENCUUKF ENUKF#%'
błędy, zanim spowodują powa ne problemy
å$'( YKFVJ JGKIJV w działaniu apletu.
åEQFGV[RG CRRNKECVKQPLCXC
RCTCO PCOG EQFG XCNWG #RRNGVENCUU Aby przechwycić błędy, należy użyć:
RCTCO PCOG V[RG XCNWG CRRNKECVKQP
åZLCXCCRRNGVXGTUKQP 1. 6GZV(KGNF RQNGICF[YCPKC PGY
RCTCO PCOG UETKRVCDNG XCNWG HCNUG å6GZV(KGNF
GODGF V[RG CRRNKECVKQPZLCXCCRRNGV KPV PCUVGRPC2TQDC
åXGTUKQP EQFG #RRNGVENCUU YKFVJ
å JGKIJV UETKRVCDNG HCNUG Powy ej definiujemy zmienną
åRNWIKPURCIG JVVRLCXCUWPEQORTQFWEVU RQNGICF[YCPKC typu 6GZV(KGNF (pole
åRNWIKPRNWIKPKPUVCNNJVON tekstowe o długości 5). Wykorzystamy
GODGF
to pole do pobierania od u ytkownika
Przechwytywanie błędów
QDLGEV
DQF[ zgadywanej liczby. Zmienna PCUVGRPC2TQDC
JVON posłu y nam do przechowywania wpisywanej
przez u ytkownika liczby — przypisujemy
jej wartość początkową . Wartość jest na
pewno niepoprawna (szukana liczba nale y
do przedziału od 1 do 100), zatem u ywamy
, by program „wiedział”, e u ytkownik
nie podał jeszcze adnej wartości.
2. KPV UWMCPC.KEDC
KPV
LCXCNCPI
å/CVJTCPFQO

15. Metoda Javy LCXCNCPI/CVJTCPFQO
generuje rzeczywistą liczbę losową
z przedziału od 0 do 1 (np. 0,722 lub 0,111).
Mno ymy tę wartość przez 100 (mamy więc
72,2 lub 11,1). Na końcu przekształcamy
tę wartość na liczbę całkowitą (rzutujemy
na typ KPV), co powoduje obcięcie części
dziesiętnej naszej liczby (otrzymujemy
zatem liczbę od 0 do 99). Po dodaniu 1
mamy wynik od 1 do 100 i przypisujemy
taką właśnie wartość zmiennej UWMCPC.KEDC.
Zarówno zmienna PCUVGRPC2TQDC,
jak i UWMCPC.KEDC są typu KPV.
89

16. Rozdział 6.
3. 5VTKPI UVCVWU.KED[ PCUVGRPC2TQDC
Aplet 6.2. Zagrajmy w grę „zgadnij, jaką sobie
åLGUV UWMCPæ NKEDæ wymyśliłem liczbę”
IUGV(QPV
H
Wewnątrz metody RCKPV
zdefiniowaliśmy KORQTV LCXCCYV

17. KORQTV LCXCCRRNGV#RRNGV
nową zmienną łańcuchową: UVCVWU.KED[.
KORQTV LCXCCYVGXGPV

18. Przypisujemy jej wartość zmiennej
PCUVGRPC2TQDC z dołączonym komunikatem RWDNKE ENCUU #RRNGV GZVGPFU #RRNGV KORNGOGPVU
o udanej próbie odgadnięcia liczby å#EVKQP.KUVGPGT ]
(patrz rysunek 6.2). W drugiej instrukcji 6GZV(KGNF RQNGICF[YCPKC PGY 6GZV(KGNF
ustawiamy czcionkę dla naszego apletu KPV PCUVGRPC2TQDC
KPV UWMCPC.KEDC
KPV
LCXCNCPI/CVJ
(za pomocą zmiennej H). åTCPFQO

19. 4. KH
PCUVGRPC2TQDC UWMCPC.KEDC ] (QPV H PGY (QPV
6KOGU4QOCP (QPV$1.
å
UVCVWU.KED[ PCUVGRPC2TQDC
PKG
åLGUV UWMCPæ NKEDæ RWDNKE XQKF KPKV
]
_ UGV$CEMITQWPF
%QNQTYJKVG
RQNGICF[YCPKCCFF#EVKQP.KUVGPGT
VJKU
Oto nasza pierwsza instrukcja KH.
CFF
RQNGICF[YCPKC
Sprawdzamy w niej, czy liczba będąca _
wartością zmiennej PCUVGRPC2TQDC ró ni się
Przechwytywanie błędów
od wylosowanej wcześniej wartości RWDNKE XQKF RCKPV
)TCRJKEU I ]
UWMCPC.KEDC; sprawdzamy zatem, 5VTKPI UVCVWU.KED[ PCUVGRPC2TQDC
czy podana przez u ytkownika liczba ró ni åLGUV UWMCPæ NKEDæ
się od wartości, którą próbuje odgadnąć. IUGV(QPV
H
Jeśli wynikiem porównania będzie VTWG KH
PCUVGRPC2TQDC UWMCPC.KEDC ]
(u ytkownikowi nie udało się odgadnąć UVCVWU.KED[ PCUVGRPC2TQDC
PKG
naszej liczby), zostanie uruchomiony åLGUV UWMCPæ NKEDæ
kod znajdujący się wewnątrz nawiasów _
klamrowych. W przeciwnym wypadku, KH
PCUVGRPC2TQDC ]
UVCVWU.KED[ 1FICFPKL NKEDú QF
ten fragment programu zostanie pominięty. åFQ
Jeśli u ytkownik nie odgadł wylosowanej _
liczby, ponownie ustawiamy zmienną IFTCY5VTKPI
UVCVWU.KED[
UVCVWU.KED[, tym razem z komunikatem _
o nieudanej próbie (patrz rysunek 6.3).
RWDNKE XQKF CEVKQP2GTHQTOGF
#EVKQP'XGPV G ]
KH
GIGV5QWTEG
KPUVCPEGQH 6GZV(KGNF ]
VT[ ]
PCUVGRPC2TQDC +PVGIGTRCTUG+PV
å
RQNGICF[YCPKCIGV6GZV
_
ECVEJ
0WODGT(QTOCV'ZEGRVKQP Z ]
PCUVGRPC2TQDC
_
TGRCKPV
_
_
_
90

20. Podejmowanie decyzji
5. KH
PCUVGRPC2TQDC ]
UVCVWU.KED[ 1FICFPKL NKEDú QF
åFQ
_
Oto kolejna instrukcja warunkowa KH.
Tym razem sprawdzamy, czy wartość
zmiennej PCUVGRPC2TQDC jest mniejsza od 1,
co oznacza, e podana wartość jest spoza
naszego przedziału. W takim przypadku
przypominamy u ytkownikowi, jakiej
Rysunek 6.2. Oto efekt, na który czekaliśmy liczby od niego oczekujemy (widać to
na rysunku 6.4).
6. IFTCY5VTKPI
UVCVWU.KED[
Za pomocą tej instrukcji wyświetlamy to,
co wcześniej przypisaliśmy wartości
UVCVWU.KED[ (odpowiedni komunikat
o trafieniu, chybieniu, bądź o podaniu
Przechwytywanie błędów
liczby spoza przedziału).
7. RWDNKE XQKF CEVKQP2GTHQTOGF
å
#EVKQP'XGPV G ]
KH
GIGV5QWTEG
KPUVCPEGQH
å6GZV(KGNF ]
Rysunek 6.3. Musisz spróbować jeszcze raz Oto metoda CEVKQP2GTHQTOGF
wyzwalana zdarzeniem generowanym
przez u ytkownika. Ten fragment kodu
jest uruchamiany za ka dym razem,
gdy u ytkownik wpisuje cokolwiek
w polu tekstowym. Na początku metody
CEVKQP2GTHQTOGF
sprawdzamy,
czy zdarzenie, które chcemy obsłu yć,
rzeczywiście dotyczy pola tekstowego.
Sprawdzamy zatem za pomocą instrukcji
warunkowej KH, czy źródłem zdarzenia
jest obiekt pola tekstowego (egzemplarz
klasy 6GZV(KGNF).
Rysunek 6.4. Jeśli wpiszesz coś innego ni liczbę,
zobaczysz taki komunikat
91

21. Rozdział 6.
8. VT[ ]
PCUVGRPC2TQDC +PVGIGTRCTUG+PV
å
RQNGICF[YCPKCIGV6GZV
_
ECVEJ
0WODGT(QTOCV'ZEGRVKQP Z ]
PCUVGRPC2TQDC
_
TGRCKPV
Instrukcja VT[ jest specyficznym rodzajem
instrukcji warunkowej. W tym przypadku
próbujemy wykonać instrukcję, która mo e
spowodować błąd. Umieszczamy ją wewnątrz
bloku VT[ ECVEJ. Jeśli jej działanie będzie
poprawne (nie spowoduje błędu), nie będzie
to miało znaczenia. W przeciwnym wypadku
spowoduje wyjątek, który nale y przechwycić
i obsłu yć (za pomocą instrukcji ECVEJ).
W tym przypadku próbujemy przekształcić
Przechwytywanie błędów
wpisany przez u ytkownika tekst na liczbę.
Poniewa w polu tekstowym u ytkownik
mo e wpisać dowolny ciąg znaków, takie
przekształcenie mo e się nie udać i stąd
konieczność u ycia bloku VT[ ECVEJ.
Jeśli podany łańcuch ma poprawny format
liczbowy, przypisujemy wartość otrzymanej
liczby zmiennej PCUVGRPC2TQDC.
W przeciwnym razie jest wyzwalany
wyjątek 0WODGT(QTOCV'ZEGRVKQP (błędny
format liczby), wówczas przypisujemy
zmiennej PCUVGRPC2TQDC wartość .
Java odrzuca nasze polecenia
Niezale nie od rezultatu przekształcenia
wywołujemy metodę TGRCKPV
, Wyjątki w Javie mo na wyrazić
która przerysuje obszar apletu. przesłaniem od programu mówiącym
„zrób to inaczej”. Źródłem wyjątków są
nieprzewidziane i niechciane
Wskazówka
zdarzenia. Przykładowo, Java nie
Powy szy przykład nie prezentuje będzie w stanie zamienić liter na liczbę.
najlepszego pomysłu na tego typu grę. Kiedy Java wyzwala wyjątek, Ty,
Średnio u ytkownik musi 50 razy programista, musisz go przechwycić.
spróbować szczęścia, zanim odgadnie Zrobisz to za pomocą słowa
wylosowaną liczbę. W następnym kluczowego ECVEJ, po którym określisz,
przykładzie zaprezentujemy du o co program Javy ma zrobić w razie
wystąpienia potencjalnych wyjątków.
ciekawsze rozwiązanie.
92

22. Podejmowanie decyzji
Listing HTML 6.3. Wyświetla aplet 6.3 w oknie
przeglądarki internetowej Więcej o instrukcjach
warunkowych — if…else
JVON
JGCF
Niekiedy niezbędne jest jedynie wyra enie
VKVNG .KUVKPI VKVNG tego, co ma się stać, jeśli dane wyra enie jest
JGCF prawdziwe. Czasem jednak będziesz chciał
DQF[ DIEQNQT YJKVG wyznaczyć instrukcje, które powinny być
QDLGEV ENCUUKF ENUKF#%' przetworzone, gdy warunek instrukcji KH nie
å$'( YKFVJ JGKIJV jest spełniony. Słu y do tego instrukcja GNUG
åEQFGV[RG CRRNKECVKQPLCXC
RCTCO PCOG EQFG XCNWG #RRNGVENCUU
wskazująca na blok kodu uruchamiany tylko
RCTCO PCOG V[RG XCNWG CRRNKECVKQP wtedy, gdy warunek instrukcji warunkowej
åZLCXCCRRNGVXGTUKQP KH nie jest spełniony. Listing HTML 6.3 i aplet
RCTCO PCOG UETKRVCDNG XCNWG HCNUG 6.3 prezentują poprawiony aplet gry „zgadnij,
GODGF V[RG CRRNKECVKQPZLCXCCRRNGV jaką sobie wymyśliłem liczbę”, który prezentuje
åXGTUKQP EQFG #RRNGVENCUU
u ytkownikowi kierunek, w którym powinien
åYKFVJ JGKIJV UETKRVCDNG HCNUG
podą ać.
Więcej o instrukcjach warunkowych
åRNWIKPURCIG JVVRLCXCUWPEQORTQFWEVU
åRNWIKPRNWIKPKPUVCNNJVON
GODGF Aby korzystać z konstrukcji if…else,
QDLGEV
DQF[
należy zastosować:
JVON 1. KH
PCUVGRPC2TQDC UWMCPC.KEDC ]
Zaczynamy od sprawdzenia, czy podana
przez u ytkownika liczba ró ni się od
wylosowanej. Fragment kodu poprzedzony
tą instrukcją warunkową zostanie wykonany
tylko w przypadku niezgodności liczby
u ytkownika z wylosowaną przez aplet.
2. KH
PCUVGRPC2TQDC ]
UVCVWU.KED[ 1FICFPKL NKEDú QF
åFQ
_
Teraz sprawdzamy, czy zmienna
PCUVGRPC2TQDC ma wartość , co
oznaczałoby, e metoda RCKPV
działa
po raz pierwszy lub e u ytkownik
wpisał ciąg znaków, którego nie mo na
przekształcić na liczbę. Jeśli warunek
jest spełniony, wyświetlamy komunikat
„Odgadnij liczbę od 1 do 100”.
93

23. Rozdział 6.
3. GNUG ] Aplet 6.3. Ulepszona wersja gry „zgadnij, jaką
sobie wymyśliłem liczbę”
W przeciwnym wypadku, jeśli wartość
zmiennej PCUVGRPC2TQDC jest ró na od
wartości zmiennej UWMCPC.KEDC oraz KORQTV LCXCCYV

24. KORQTV LCXCCRRNGV#RRNGV
PCUVGRPC2TQDC jest poprawną liczbą, KORQTV LCXCCYVGXGPV

25. uruchamiamy fragment kodu poprzedzony
słowem GNUG. W tym przypadku fragment RWDNKE ENCUU #RRNGV GZVGPFU #RRNGV KORNGOGPVU
składa się z kolejnego bloku KH GNUG. å#EVKQP.KUVGPGT ]
6GZV(KGNF RQNGICF[YCPKC PGY 6GZV(KGNF
4. KH
PCUVGRPC2TQDC UWMCPC.KEDC ] KPV PCUVGRPC2TQDC
UVCVWU.KED[ PCUVGRPC2TQDC
KPV UWMCPC.KEDC
KPV
LCXCNCPI/CVJ
åTCPFQO

26. åVQ C OC Q (QPV H PGY (QPV
6KOGU4QOCP (QPV$1.
_ å
GNUG ]
UVCVWU.KED[ PCUVGRPC2TQDC
RWDNKE XQKF KPKV
]
åVQ C FW Q UGV$CEMITQWPF
%QNQTYJKVG
_ RQNGICF[YCPKCCFF#EVKQP.KUVGPGT
VJKU
Więcej o instrukcjach warunkowych
CFF
RQNGICF[YCPKC
Teraz sprawdzamy, czy wartość zmiennej _
PCUVGRPC2TQDC jest mniejsza od wartości
RWDNKE XQKF RCKPV
)TCRJKEU I ]
przechowywanej w zmiennej UWMCPC.KEDC. 5VTKPI UVCVWU.KED[ PCUVGRPC2TQDC
Jeśli tak, zmienna PCUVGRPC2TQDC będzie åLGUV UWMCPæ NKEDæ
wyświetlona z komunikatem, e podana
liczba jest za mała. W przeciwnym razie IUGV(QPV
H
KH
PCUVGRPC2TQDC UWMCPC.KEDC ]
zakomunikujemy u ytkownikowi, e jest KH
PCUVGRPC2TQDC ]
za du a. Na rysunku 6.5 prezentujemy UVCVWU.KED[ 1FICFPKL NKEDú QF
wygląd apletu, gdy podana liczba jest åFQ
za du a, rysunki 6.6 i 6.7 prezentują efekt _
GNUG ]
dla zbyt małej liczby. Jeśli w końcu podamy KH
PCUVGRPC2TQDC UWMCPC.KEDC ]
liczbę równą szukanej, zobaczymy UVCVWU.KED[ PCUVGRPC2TQDC
VQ
komunikat widoczny na rysunku 6.8. åC OC Q
_
GNUG ]
UVCVWU.KED[ PCUVGRPC2TQDC
VQ
åC FW Q
_
_
_
IFTCY5VTKPI
UVCVWU.KED[
_
RWDNKE XQKF CEVKQP2GTHQTOGF
#EVKQP'XGPV G ]
KH
GIGV5QWTEG
KPUVCPEGQH 6GZV(KGNF ]
VT[ ]
PCUVGRPC2TQDC +PVGIGTRCTUG+PV
å
RQNGICF[YCPKCIGV6GZV
_
ECVEJ
0WODGT(QTOCV'ZEGRVKQP Z ]
PCUVGRPC2TQDC
_
TGRCKPV
_
_
_
94

27. Podejmowanie decyzji
Wskazówka
W poprzednim przypadku u ytkownik
musiał próbować 50 razy, by osiągnąć 50%
szans na sukces. W tym przypadku mamy
taką samą mo liwość odgadnięcia liczby
po najwy ej siedmiu próbach.
Rysunek 6.5. Zaczniemy od liczby 50 i zobaczymy,
czy jest za du a czy za mała
Więcej o instrukcjach warunkowych
Rysunek 6.6. Połowa z ró nicy między 50 a 100
to 75 — okazuje się, e to za du o
Rysunek 6.7. Połowa z ró nicy między 50 a 75
to 62 — tym razem za mało
Rysunek 6.8. Tym razem podajemy 71 — nareszcie,
prawidłowa wartość
95

28. Rozdział 6.
Listing HTML 6.4. Oto, jak mo emy wywołać nasz
Powtarzanie czynności nowy aplet
za pomocą pętli
Struktura KH GNUG, którą posługiwaliśmy się JVON
JGCF
w poprzednim przykładzie, pozwalała uruchamiać VKVNG .KUVKPI VKVNG
albo jeden, albo drugi blok kodu. W przyszłości JGCF
często mo esz stawać przed koniecznością wpisania DQF[ DIEQNQT YJKVG
jednej lub wielu instrukcji, które powinny być QDLGEV ENCUUKF ENUKF#%'
uruchomione wielokrotnie. Rozwiązaniem, które å$'( YKFVJ JGKIJV
pozwala to zrealizować, jest pętla. Listing HTML åEQFGV[RG CRRNKECVKQPLCXC
6.4 i aplet 6.4 demonstrują jeden z rodzajów pętli: RCTCO PCOG EQFG XCNWG #RRNGVENCUU
RCTCO PCOG V[RG XCNWG CRRNKECVKQP
HQT. W poni szym przykładzie umo liwimy
åZLCXCCRRNGVXGTUKQP
u ytkownikowi wpisanie liczby, na podstawie RCTCO PCOG UETKRVCDNG XCNWG HCNUG
której wyświetlimy rząd gwiazdek w oknie GODGF V[RG CRRNKECVKQPZLCXCCRRNGV
przeglądarki. åXGTUKQP EQFG #RRNGVENCUU YKFVJ
å JGKIJV UETKRVCDNG HCNUG
Powtarzanie czynności za pomocą pętli
åRNWIKPURCIG JVVRLCXCUWPEQORTQFWEVU
Zapętlenie kodu åRNWIKPRNWIKPKPUVCNNJVON
GODGF
Pętla HQT składa się z trzech części (patrz
QDLGEV
rysunek 6.10): DQF[
1. Inicjalizacja — podczas pierwszego JVON
przejścia pętli inicjalizowana jest
zmienna pętli — licznik pętli.
2. Ograniczenie — tak określamy, kiedy
pętla się zakończy. W normalnych
warunkach ludzie odliczają od jednego
do dziesięciu; powszechną praktyką
w językach programowania jest
odliczanie od zera do dziewięciu.
W obu przypadkach kod wewnątrz
pętli zostanie przetworzony dziesięć
razy, jednak metoda liczenia od
zera jest wygodniejsza w językach
programowania takich jak Java z racji
indeksowania tablic od zera. Dlatego
właśnie określamy ograniczenia Rysunek 6.9. U ytkownik poprosił o 29 gwiazdek
w pętli jako „mniejszy ni wartość i natychmiast je otrzymał
NKEDC7[VMQYPKMC”, a nie „mniejszy
lub równy wartości NKEDC7[VMQYPKMC”.
3. Inkrementacja — w tej części
określamy, jak dalece zwiększać
licznik pętli w ka dej kolejnej iteracji
pętli. W tym przypadku dodajemy
jeden za pomocą znaków
po identyfikatorze zmiennej.
Rysunek 6.10. Trzy części pętli
96

29. Podejmowanie decyzji
Aplet 6.4. Aplet „pyta” u ytkownika o liczbę Aby korzystać z pętli for,
gwiazdek i wyświetla je za pomocą pętli
należy zastosować:
KORQTV LCXCCYV

30. 1. KH
NKEDC7[VMQYPKMC ^^
KORQTV LCXCCRRNGV#RRNGV åNKEDC7[VMQYPKMC ]
KORQTV LCXCCYVGXGPV

31. NCPEWEJ9[LUEKQY[ 2QFCL NKEDú QF
åFQ
RWDNKE ENCUU #RRNGV GZVGPFU #RRNGV KORNGOGPVU _
å#EVKQP.KUVGPGT ]
6GZV(KGNF RQNG7[VMQYPKMC PGY 6GZV(KGNF
Na początku upewniamy się, czy u ytkownik
KPV NKEDC7[VMQYPKMC wpisał liczbę mieszczącą się w zało onym
(QPV H PGY (QPV
6KOGU4QOCP (QPV$1. przedziale (od 1 do 50).
å
2. GNUG ]
RWDNKE XQKF KPKV
] HQT
K KNKEDC7[VMQYPKMC K
]
UGV$CEMITQWPF
%QNQTYJKVG
NCPEWEJ9[LUEKQY[ NCPEWEJ9[LUEKQY[
RQNG7[VMQYPKMCCFF#EVKQP.KUVGPGT
VJKU
å

32. Powtarzanie czynności za pomocą pętli
CFF
RQNG7[VMQYPKMC
_ _
_
RWDNKE XQKF RCKPV
)TCRJKEU I ]
5VTKPI NCPEWEJ9[LUEKQY[
Jeśli liczba jest prawidłowa (nie spełniony
KPV K warunek instrukcji KH z poprzedniego kroku),
przechodzimy do pętli HQT. Pierwsza część
IUGV(QPV
H inicjalizuje licznik pętli K wartością .
KH
NKEDC7[VMQYPKMC ^^ W drugiej części określamy, e pętla będzie
åNKEDC7[VMQYPKMC ]
działać tak długo, a K będzie mniejsze
NCPEWEJ9[LUEKQY[ 2QFCL NKEDú QF
åFQ od wartości podanej przez u ytkownika.
_ Trzeci element określa operację wykonywaną
GNUG ] przy ka dej iteracji pętli, w tym przypadku
HQT
K KNKEDC7[VMQYPKMC K
] licznik pętli będzie zwiększany o .
NCPEWEJ9[LUEKQY[ NCPEWEJ9[LUEKQY[
Na rysunku 6.9 widać efekt działania
å

33. _
apletu po tym, jak u ytkownik wpisał „29”.
_ Do zmiennej NCPEWEJ9[LUEKQY[ (początkowo
IFTCY5VTKPI
NCPEWEJ9[LUEKQY[ jest pustym łańcuchem) dodajemy gwiazdkę
_ przy ka dym nawrocie pętli.
RWDNKE XQKF CEVKQP2GTHQTOGF
#EVKQP'XGPV G ] Wskazówka
KH
GIGV5QWTEG
KPUVCPEGQH 6GZV(KGNF ]
VT[ ] Znaki ^^ pomiędzy warunkami
NKEDC7[VMQYPKMC +PVGIGTRCTUG+PV sprawdzającymi, czy NKEDC7[VMQYPKMC
å
RQNG7[VMQYPKMCIGV6GZV
jest mniejsza od 1 i większa ni 50
_
ECVEJ
0WODGT(QTOCV'ZEGRVKQP Z ] oznaczają logiczną alternatywę (czyli „lub”).
NKEDC7[VMQYPKMC Mówi to, e cały warunek KH jest prawdziwy,
_ jeśli choć jeden z warunków składowych
TGRCKPV
(rozdzielonych ^^) jest prawdziwy.
_ Gdybyśmy chcieli, by konieczna
_
była prawdziwość oby warunków,
_
rozdzielilibyśmy je znakami
oznaczającymi koniunkcję (czyli „i”).
97

34. Rozdział 6.
Listing HTML 6.5. Wstawia aplet 6.5 na stronę WWW
Inny rodzaj pętli — while
W Javie istnieją trzy sposoby budowania pętli. JVON
Pierwszym jest pętla omówiona w poprzednim JGCF
przykładzie — pętla HQT, dwie pozostałe VKVNG .KUVKPI VKVNG
to odmiany pętli YJKNG. Kod zawarty w pętli JGCF
DQF[ DIEQNQT YJKVG
YJKNG działa tak długo, jak długo spełniony
QDLGEV ENCUUKF ENUKF#%'
jest warunek tej pętli (patrz listing HTML 6.5 å$'( YKFVJ JGKIJV
i aplet 6.5). Przy pierwszym sprawdzeniu tego åEQFGV[RG CRRNKECVKQPLCXC
warunku, które wyka e jego nieprawdziwość, RCTCO PCOG EQFG XCNWG #RRNGVENCUU
działanie pętli jest kończone. Jeśli ju przy RCTCO PCOG V[RG XCNWG CRRNKECVKQP
pierwszym sprawdzeniu, warunek oka e się åZLCXCCRRNGVXGTUKQP
RCTCO PCOG UETKRVCDNG XCNWG HCNUG
nieprawdziwy, pętla w ogóle nie zostanie GODGF V[RG CRRNKECVKQPZLCXCCRRNGV
uruchomiona. åXGTUKQP EQFG #RRNGVENCUU YKFVJ
å JGKIJV UETKRVCDNG HCNUG
åRNWIKPURCIG JVVRLCXCUWPEQORTQFWEVU
åRNWIKPRNWIKPKPUVCNNJVON
GODGF
QDLGEV
Inny rodzaj pętli — while
DQF[
JVON
Rysunek 6.11. Teraz u ytkownik poprosił jedynie
o trzy gwiazdki
98

35. Podejmowanie decyzji
Aplet 6.5. Ciekawe, ile gwiazdek u ytkownik będzie Aby używać pętli while, należy wpisać:
chciał wyświetlić tym razem
1. YJKNG
K NKEDC7[VMQYPKMC
NCPEWEJ9[LUEKQY[ NCPEWEJ9[LUEKQY[
KORQTV LCXCCYV

36. å

37. KORQTV LCXCCRRNGV#RRNGV K
KORQTV LCXCCYVGXGPV

38. _
RWDNKE ENCUU #RRNGV GZVGPFU #RRNGV Wartość zmiennej NKEDC7[VMQYPKMC
åKORNGOGPVU #EVKQP.KUVGPGT ]
albo mieści się w przedziale od 1 do 50
6GZV(KGNF RQNG7[VMQYPKMC PGY 6GZV(KGNF
KPV NKEDC7[VMQYPKMC (wówczas jest prawidłowa), albo wynosi
(QPV H PGY (QPV
6KOGU4QOCP (QPV$1. (jeśli u ytkownik wpisał niepoprawny
å łańcuch). Poniewa K jest inicjalizowane
wartością , powy sza pętla w ogóle
RWDNKE XQKF KPKV
] nie zadziała, jeśli nie podano prawidłowej
UGV$CEMITQWPF
%QNQTYJKVG
RQNG7[VMQYPKMCCFF#EVKQP.KUVGPGT
VJKU
wartości, poniewa nie jest większe od .
CFF
RQNG7[VMQYPKMC Jeśli podana przez u ytkownika wartość
_ jest prawidłowa, kod zawarty w pętli zostanie
przetworzony tyle razy, ile przypisano
RWDNKE XQKF RCKPV
)TCRJKEU I ] zmiennej NKEDC7[VMQYPKMC. Za ka dym
Inny rodzaj pętli — while
5VTKPI NCPEWEJ9[LUEKQY[ razem zmienna K jest zwiększana o 1.
KPV K
Przykładowo, jeśli wartość zmiennej
IUGV(QPV
H NKEDC7[VMQYPKMC wynosi , pętla
KH
NKEDC7[VMQYPKMC ] uruchomi się 25 razy. Jeśli NKEDC7[VMQYPKMC
NKEDC7[VMQYPKMC wynosi , pętla YJKNG przed pierwszym
_ uruchomieniem stwierdzi nieprawdziwość
KH
NKEDC7[VMQYPKMC ]
warunku K NKEDC7[VMQYPKMC
NCPEWEJ9[LUEKQY[ 2QFCL NKEDú QF
åFQ i nie uruchomi się ani razu.
_
YJKNG
K NKEDC7[VMQYPKMC ] Wskazówka
NCPEWEJ9[LUEKQY[ NCPEWEJ9[LUEKQY[

39. K
Upewnij się, e pętla YJKNG kiedyś się
_ zakończy. Gdybyś, przykładowo, pominął
IFTCY5VTKPI
NCPEWEJ9[LUEKQY[ instrukcję K
w powy szym przykładzie,
_ stworzył byś nieskończoną pętlę, czyli taką,
która sama nigdy się nie zakończy.
RWDNKE XQKF CEVKQP2GTHQTOGF
#EVKQP'XGPV G ]
KH
GIGV5QWTEG
KPUVCPEGQH 6GZV(KGNF ]
VT[ ]
NKEDC7[VMQYPKMC +PVGIGTRCTUG+PV
å
RQNG7[VMQYPKMCIGV6GZV
_
ECVEJ
0WODGT(QTOCV'ZEGRVKQP Z ]
NKEDC7[VMQYPKMC
_
TGRCKPV
_
_
_
99

40. Rozdział 6.
Listing HTML 6.6. Poni szy plik HTML wywołuje
Ostatni rodzaj pętli aplet 6.6 zawierający pętlę do…while
— do…while
JVON
Trzecim i ostatnim typem pętli w Javie jest JGCF
FQ YJKNG. W układzie FQ YJKNG sprawdzamy VKVNG .KUVKPI VKVNG
warunek pętli na końcu pętli, a nie na początku. JGCF
Oznacza to, e pętla zawsze się uruchomi DQF[ DIEQNQT YJKVG
przynajmniej raz. Listing HTML 6.6 i aplet 6.6 QDLGEV ENCUUKF ENUKF#%'
å$'( YKFVJ JGKIJV
prezentują zastosowanie pętli FQ YJKNG.
åEQFGV[RG CRRNKECVKQPLCXC
RCTCO PCOG EQFG XCNWG #RRNGVENCUU
Aby użyć pętli do…while, RCTCO PCOG V[RG XCNWG CRRNKECVKQP
należy wpisać: åZLCXCCRRNGVXGTUKQP
RCTCO PCOG UETKRVCDNG XCNWG HCNUG
1. FQ ] GODGF V[RG CRRNKECVKQPZLCXCCRRNGV
NCPEWEJ9[LUEKQY[ NCPEWEJ9[LUEKQY[
åXGTUKQP EQFG #RRNGVENCUU YKFVJ
å

41. å JGKIJV UETKRVCDNG HCNUG
åRNWIKPURCIG JVVRLCXCUWPEQORTQFWEVU
K
Ostatni rodzaj pętli — do…while
åRNWIKPRNWIKPKPUVCNNJVON
_ YJKNG
K NKEDC7[VMQYPKMC GODGF
W takim układzie zmienna łańcuchowa QDLGEV
DQF[
NCPEWEJ9[LUEKQY[ będzie zawsze zawierała JVON
przynajmniej jedną gwiazdkę. Musimy
więc uwa ać, w jaki sposób umieścimy
ten fragment w naszym programie
— w tym przypadku sprawdzamy przed
wejściem do pętli, czy wartość zmiennej
NKEDC7[VMQYPKMC jest poprawna
(od 1 do 50).
Pętla będzie działać tak długo, jak długo
K będzie mniejsze od NKEDC7[VMQYPKMC.
Efekt widać na rysunku 6.12.
Rysunek 6.12. U ytkownik za ądał 34 gwiazdki
100

42. Podejmowanie decyzji
Aplet 6.6. Za pomocą pętli do…while przetwarzamy
ądanie u ytkownika
KORQTV LCXCCYV

43. KORQTV LCXCCRRNGV#RRNGV
KORQTV LCXCCYVGXGPV

44. RWDNKE ENCUU #RRNGV GZVGPFU #RRNGV KORNGOGPVU
å#EVKQP.KUVGPGT ]
6GZV(KGNF RQNG7[VMQYPKMC PGY 6GZV(KGNF
KPV NKEDC7[VMQYPKMC
(QPV H PGY (QPV
6KOGU4QOCP (QPV$1.
å
RWDNKE XQKF KPKV
]
UGV$CEMITQWPF
%QNQTYJKVG
RQNG7[VMQYPKMCCFF#EVKQP.KUVGPGT
VJKU
CFF
RQNG7[VMQYPKMC
_
Ostatni rodzaj pętli — do…while
RWDNKE XQKF RCKPV
)TCRJKEU I ]
5VTKPI NCPEWEJ9[LUEKQY[
KPV K
IUGV(QPV
H
KH
NKEDC7[VMQYPKMC ^^
åNKEDC7[VMQYPKMC ]
NCPEWEJ9[LUEKQY[ 2QFCL NKEDú QF
åFQ
_
GNUG ]
FQ ]
NCPEWEJ9[LUEKQY[ NCPEWEJ9[LUEKQY[
å

45. K
_ YJKNG
K NKEDC7[VMQYPKMC
_
IFTCY5VTKPI
NCPEWEJ9[LUEKQY[
_
RWDNKE XQKF CEVKQP2GTHQTOGF
#EVKQP'XGPV G ]
KH
GIGV5QWTEG
KPUVCPEGQH 6GZV(KGNF ]
VT[ ]
NKEDC7[VMQYPKMC +PVGIGTRCTUG+PV
å
RQNG7[VMQYPKMCIGV6GZV
_
ECVEJ
0WODGT(QTOCV'ZEGRVKQP Z ]
NKEDC7[VMQYPKMC
_
TGRCKPV
_
_
_
101

46. Rozdział 6.
Listing HTML 6.7. Wstawia na stronę aplet 6.7
Przerywanie działania pętli
Istnieje mo liwość opuszczenia pętli JVON
przetwarzanej zgodnie z jej warunkami. JGCF
Taki sposób kończenia pętli mo na uzyskać VKVNG .KUVKPI VKVNG
za pomocą instrukcji DTGCM. JGCF
DQF[ DIEQNQT YJKVG
W listingu HTML 6.7 i aplecie 6.7 u ytkownik QDLGEV ENCUUKF ENUKF#%'
mo e wpisać dowolną liczbę. Niezale nie å$'( YKFVJ JGKIJV
åEQFGV[RG CRRNKECVKQPLCXC
jednak od jej wielkości, pętla nie zadziała
RCTCO PCOG EQFG XCNWG #RRNGVENCUU
więcej ni dwadzieścia razy. RCTCO PCOG V[RG XCNWG CRRNKECVKQP
åZLCXCCRRNGVXGTUKQP
Aby przerwać działanie pętli, RCTCO PCOG UETKRVCDNG XCNWG HCNUG
GODGF V[RG CRRNKECVKQPZLCXCCRRNGV
należy użyć: åXGTUKQP EQFG #RRNGVENCUU YKFVJ
1. HQT
K KNKEDC7[VMQYPKMC K
] å JGKIJV UETKRVCDNG HCNUG
åRNWIKPURCIG JVVRLCXCUWPEQORTQFWEVU
KH
K DTGCM
åRNWIKPRNWIKPKPUVCNNJVON
NCPEWEJ9[LUEKQY[ NCPEWEJ9[LUEKQY[
GODGF
å

47. QDLGEV
Przerywanie działania pętli
_ DQF[
JVON
To jest standardowa pętla HQT, która
w najprostszej formie działałaby a
do osiągnięcia przez licznik K wartości
zmiennej NKEDC7[VMQYPKMC. Wstawienie
instrukcji DTGCM wewnątrz pętli sprawi,
e jej działanie zostanie przerwane,
gdy K osiągnie wartość .
Instrukcja DTGCM powoduje skok
do pierwszej instrukcji znajdującej się
za pętlą — w naszym przypadku jest to
IFTCY5VTKPI
NCPEWEJ9[LUEKQY[ .
Efekt jest widoczny na rysunku 6.13.
Rysunek 6.13. Niezale nie od tego, jaką liczbę
podamy, zobaczymy maksymalnie 20 gwiazdek
102

48. Podejmowanie decyzji
Aplet 6.7. Demonstruje opuszczenie pętli za pomocą Wskazówka
instrukcji break
W Javie istnieje tak e instrukcja EQPVKPWG.
Kiedy jej u yjemy, następujący po niej
KORQTV LCXCCYV

49. fragment kodu wewnątrz pętli zostanie
KORQTV LCXCCRRNGV#RRNGV pominięty, nie przerywamy jednak jej
KORQTV LCXCCYVGXGPV

50. działania. W powy szym przypadku,
RWDNKE ENCUU #RRNGV GZVGPFU #RRNGV KORNGOGPVU gdybyśmy zastąpili instrukcję DTGCM
å#EVKQP.KUVGPGT ] instrukcją EQPVKPWG, pomijane byłyby
6GZV(KGNF RQNG7[VMQYPKMC PGY 6GZV(KGNF
instrukcje dopisywania gwiazdki do
KPV NKEDC7[VMQYPKMC zmiennej NCPEWEJ9[LUEKQY[ od momentu
(QPV H PGY (QPV
6KOGU4QOCP (QPV$1.
osiągnięcia przez K wartości .
å
W przeciwieństwie jednak do przerwania
RWDNKE XQKF KPKV
] działania pętli instrukcją DTGCM, gdybyśmy
UGV$CEMITQWPF
%QNQTYJKVG u yli EQPVKPWG, pętla działałaby nadal,
RQNG7[VMQYPKMCCFF#EVKQP.KUVGPGT
VJKU a do momentu zrównania się licznika K
CFF
RQNG7[VMQYPKMC z wartością zmiennej NKEDC7[VMQYPKMC.
_
Przerywanie działania pętli
RWDNKE XQKF RCKPV
)TCRJKEU I ]
5VTKPI NCPEWEJ9[LUEKQY[
KPV K
IUGV(QPV
H
KH
NKEDC7[VMQYPKMC ]
NCPEWEJ9[LUEKQY[ 2QFCL NKEDú QF
åFQ
_
GNUG ]
HQT
K KNKEDC7[VMQYPKMC K
]
KH
K DTGCM
NCPEWEJ9[LUEKQY[ NCPEWEJ9[LUEKQY[
å

51. _
_
IFTCY5VTKPI
NCPEWEJ9[LUEKQY[
_
RWDNKE XQKF CEVKQP2GTHQTOGF
#EVKQP'XGPV G ]
KH
GIGV5QWTEG
KPUVCPEGQH 6GZV(KGNF ]
VT[ ]
NKEDC7[VMQYPKMC +PVGIGTRCTUG+PV
å
RQNG7[VMQYPKMCIGV6GZV
_
ECVEJ
0WODGT(QTOCV'ZEGRVKQP Z ]
NKEDC7[VMQYPKMC
_
TGRCKPV
_
_
_
103

52. Rozdział 6.
Listing HTML 6.8. Tak wstawiamy naszą grę
Konstrukcja switch…case zapisaną w aplecie 6.8
Java oferuje jeszcze jeden sposób kontrolowania
przetwarzania kodu — konstrukcję UYKVEJ ECUG. JVON
Najprostszym sposobem zrozumienia istoty JGCF
tej instrukcji jest spojrzenie na nią jak na zbiór VKVNG .KUVKPI VKVNG
instrukcji KH GNUG. Zamiast powiedzieć: „jeśli JGCF
DQF[ DIEQNQT YJKVG
dzisiaj jest poniedziałek, zrób to; w przeciwnym QDLGEV ENCUUKF ENUKF#%'
razie, jeśli dzisiaj jest wtorek, zrób coś innego; å$'( YKFVJ JGKIJV
w przeciwnym razie, jeśli dzisiaj jest środa, åEQFGV[RG CRRNKECVKQPLCXC
zrób coś jeszcze innego itd.”, mo emy u yć RCTCO PCOG EQFG XCNWG #RRNGVENCUU
konstrukcji UYKVEJ ECUG, by bezpośrednio RCTCO PCOG V[RG XCNWG CRRNKECVKQP
åZLCXCCRRNGVXGTUKQP
wyró nić ka dą z mo liwości.
RCTCO PCOG UETKRVCDNG XCNWG HCNUG
Listing HTML 6.8 i aplet 6.8 prezentują grę GODGF V[RG CRRNKECVKQPZLCXCCRRNGV
åXGTUKQP EQFG #RRNGVENCUU YKFVJ
w kamień, no yce i papier napisaną z u yciem
å JGKIJV UETKRVCDNG HCNUG
konstrukcji UYKVEJ ECUG. åRNWIKPURCIG JVVRLCXCUWPEQORTQFWEVU
åRNWIKPRNWIKPKPUVCNNJVON
ch…case
Aby użyć instrukcji switch…case, GODGF
Konstrukcja switch…case
QDLGEV
należy zastosować: DQF[
1. RWDNKE ENCUU #RRNGV GZVGPFU #RRNGV
åKORNGOGPVU +VGO.KUVGPGT ]
Poniewa w naszym nowym aplecie
do interakcji z u ytkownikiem posłu ymy się
przyciskami opcji zamiast polem tekstowym,
musimy u yć zupełnie innych metod
do przechwytywania zdarzeń. Korzystamy
więc z interfejsu +VGO.KUVGPGT, który
dostarcza nam metodę KVGO5VCVG%JCPIGF
wyzwalaną przez zdarzenie kliknięcia
przycisku opcji.
2. %JGEMDQZ)TQWR WUGT%JGEMDQZ
%JGEMDQZ MCOKGP%JGEM$QZ PQ[EG%JGEM$QZ
åRCRKGT%JGEM$QZ
Ka dy przycisk opcji %JGEMDQZ jest
początkowo definiowany jako pole wyboru.
Później, w kroku 4., określimy, e wszystkie
trzy pola będą przyciskami opcji nale ącymi
do jednej grupy %JGEMDQZ)TQWR.
3. WUGT%JGEMDQZ PGY %JGEMDQZ)TQWR
Tworzymy obiekt klasy %JGEMDQZ)TQWR
(grupa pól wyboru) nazwany WUGT%JGEMDQZ.
104

53. Podejmowanie decyzji
Aplet 6.8. Zobaczmy, czy mo emy wygrać 4. MCOKGP%JGEM$QZ PGY %JGEMDQZ
-COKG
z naszym apletem åWUGT%JGEMDQZ HCNUG
MCOKGP%JGEM$QZCFF+VGO.KUVGPGT
VJKU
KORQTV LCXCCYV

54. åCFF
MCOKGP%JGEM$QZ
KORQTV LCXCCRRNGV#RRNGV Te trzy instrukcje tworzą przycisk opcji
KORQTV LCXCCYVGXGPV

55. MCOKGP%JGEM$QZ będący częścią grupy
RWDNKE ENCUU #RRNGV GZVGPFU #RRNGV KORNGOGPVU WUGT%JGEMDQZ. Klikając którykolwiek
å+VGO.KUVGPGT ] przycisk nale ący do tej grupy, spowodujesz,
KPV NKEDC#RNGVW
KPV
LCXCNCPI/CVJ e wszystkie pozostałe przyciski z tej grupy
åTCPFQO