Darmowy fragment publikacji:
IDZ DO
IDZ DO
PRZYK£ADOWY ROZDZIA£
PRZYK£ADOWY ROZDZIA£
SPIS TREĎCI
SPIS TREĎCI
Po prostu Java 2
KATALOG KSI¥¯EK
KATALOG KSI¥¯EK
KATALOG ONLINE
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
TWÓJ KOSZYK
DODAJ DO KOSZYKA
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
ZAMÓW INFORMACJE
O NOWOĎCIACH
O NOWOĎCIACH
ZAMÓW CENNIK
ZAMÓW CENNIK
CZYTELNIA
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
Autor: Dori Smith
T³umaczenie: Miko³aj Szczepaniak
ISBN: 83-7197-686-0
Tytu³ orygina³u: Java 2 for the World Wide Web VQG
Format: B5, stron: 356
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.
Spis treści
Spis treści
Wstęp
11
Rozdział 1. Czym jest Java?
17
Krótka lekcja historii...................................................c.............................. 18
Dlaczego uczyć się Javy?...................................................c....................... 20
Rozpowszechnione mity o Javie ...................................................c............ 21
Co będzie Ci potrzebne ...................................................c.......................... 24
Wersje Javy...................................................c............................................ 25
Rozdział 2. Podstawy Javy
27
Wprowadzenie w niesamowity świat Wirtualnej Maszyny Javy.............. 28
Bezpieczeństwo Javy ...................................................c............................. 29
Pliki Javy...................................................c................................................ 30
Gra w Buzzword Bingo ...................................................c......................... 31
Rozdział 3. Używanie Javy na stronach WWW
37
Znacznik APPLET ...................................................c................................. 38
S
p
i
s
t
r
e
ś
c
i
Znacznik OBJECT ...................................................c................................. 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 ...................................................c........ 49
Przekazywanie parametrów do apletu...................................................c.... 51
Rozdział 4. Twoje pierwsze aplety
55
„Witaj świecie!”...................................................c..................................... 56
Posługiwanie się czcionkami ...................................................c................. 58
Ustawianie koloru tła ...................................................c............................. 59
Przekazywanie parametrów z pliku HTML do apletu Javy ...................... 60
Dodawanie komentarzy ...................................................c......................... 62
Zmiana stylu czcionki ...................................................c............................ 63
Zmiana kolorów ...................................................c..................................... 64
5
i
c
ś
e
r
t
s
i
p
S
Spis treści
Rozdział 5.
65
Łańcuchy
Zmienne łańcuchowe ...................................................c............................. 66
Więcej o łańcuchach ...................................................c.............................. 68
Zasięg deklaracji zmiennych...................................................c.................. 70
Metody klasy String...................................................c............................... 72
Wszystkie typy liczbowe ...................................................c....................... 74
Wzajemne przekształcanie łańcuchów i liczb........................................... 77
Przekształcenia typów liczbowych ...................................................c........ 79
Przekształcanie przez rzutowanie ...................................................c.......... 81
Tablice obiektów...................................................c.................................... 83
Rozdział 6. Podejmowanie decyzji
85
Instrukcje warunkowe — if ...................................................c................... 86
Przechwytywanie błędów ...................................................c...................... 89
Więcej o instrukcjach warunkowych — if…else ..................................... 93
Powtarzanie czynności za pomocą pętli...................................................c. 96
Inny rodzaj pętli — while ...................................................c...................... 98
Ostatni rodzaj pętli — do…while ...................................................c........ 100
Przerywanie działania pętli ...................................................c.................. 102
Konstrukcja switch…case...................................................c.................... 104
Rozdział 7. Współpraca z użytkownikiem
109
Rysowanie za pomocą myszy ...................................................c.............. 110
Rysowanie w dwóch wymiarach ...................................................c......... 113
Swobodne rysowanie ...................................................c........................... 116
Przechwytywanie naciskania klawiszy ...................................................c 118
Przemieszczanie obrazów ...................................................c.................... 120
Używanie klawiszy modyfikujących ...................................................c... 122
Rozdział 8. Budowa interfejsu użytkownika
125
Strony chronione hasłem...................................................c...................... 126
Wpisywanie i wyświetlanie tekstu...................................................c....... 129
Praca z polami wyboru...................................................c......................... 131
Używanie przycisków opcji ...................................................c................. 134
Elementy rozwijanego menu...................................................c................ 137
Ustawianie menu czcionki w Javie ...................................................c...... 139
Używanie wieloliniowych pól tekstowych ............................................. 141
Używanie list przewijanych ...................................................c................. 144
6
Spis treści
Rozdział 9. Rozmieszczanie elementów interfejsu użytkownika
147
Brak rozmieszczenia — FlowLayout...................................................c... 148
Używanie menadżera FlowLayout...................................................c....... 150
Wstawianie wolnych przestrzeni w obszarze apletu............................... 152
Używanie menadżera BorderLayout...................................................c.... 154
Używanie menadżera GridLayout ...................................................c....... 156
Używanie wkładek...................................................c............................... 158
Dodawanie komponentów z wykorzystaniem paneli.............................. 160
Używanie menadżera CardLayout ...................................................c....... 162
Używanie menadżera GridBagLayout ...................................................c. 165
Rozdział 10. Manipulowanie obrazami i animacje
169
Wyświetlanie obrazu...................................................c............................ 170
Wyświetlanie fragmentu obrazu ...................................................c.......... 172
Rysowanie ramki wokół apletu...................................................c............ 174
Wyświetlanie wielu obrazów ...................................................c............... 176
Wątki i animacja ...................................................c.................................. 179
Podwójnie buforowane animacje ...................................................c......... 183
Wyświetlanie nieskończonej liczby obrazów ......................................... 186
Kontrola animacji...................................................c................................. 188
Rozdział 11. Java i JavaScript
191
Sprawdzanie obsługi Javy przez przeglądarkę........................................ 192
JavaScript i publiczne metody Javy ...................................................c..... 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 ...................................................c.............................. 208
Przyciski opcji Swing ...................................................c.......................... 211
Wygląd apletu zgodny z preferencjami użytkownika............................. 214
Animacja i Swing...................................................c................................. 219
Swing w akcji...................................................c....................................... 223
S
p
i
s
t
r
e
ś
c
i
7
Spis treści
Rozdział 13. JavaServer Pages i Serwlety Javy
231
Twoja pierwsza strona JSP ...................................................c.................. 232
JSP i formularze...................................................c................................... 234
Instrukcje warunkowe w JSP ...................................................c............... 236
Zapisywanie cookies za pomocą JSP...................................................c... 238
Odczytywanie cookies za pomocą JSP ...................................................c 240
XML i JSP ...................................................c........................................... 243
Twój pierwszy serwlet ...................................................c......................... 245
Ankieta i serwlety ...................................................c................................ 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
i
c
ś
e
r
t
s
i
p
S
Rozdział 15. Kółko i krzyżyk
267
Gra w kółko i krzyżyk...................................................c.......................... 268
Rozdział 16. Prosty kalkulator
283
Aplet z prostym kalkulatorem...................................................c.............. 284
Rozdział 17. Prawdziwy świat Javy — hierarchiczne menu
291
Java i hierarchiczne menu ...................................................c.................... 292
Dodatek A Gdzie szukać dodatkowych informacji?
307
Java w Internecie...................................................c.................................. 308
Czasopisma internetowe ...................................................c...................... 311
Zintegrowane środowiska oprogramowania ........................................... 312
Książki o Javie ...................................................c..................................... 314
Grupy dyskusyjne ...................................................c................................ 316
Witryny internetowe a przenośność Javy................................................ 317
Dodatek B Zarezerwowane słowa kluczowe
319
Zarezerwowane słowa kluczowe Javy ...................................................c. 320
Dodatek C Hierarchia obiektów Javy
323
Pakiet java.applet ...................................................c................................. 324
Pakiet java.awt ...................................................c.................................... 324
Pakiet java.awt.color (wprowadzony w JDK 1.2) .................................. 325
Pakiet java.awt.datatransfer (wprowadzony w JDK 1.1)........................ 326
8
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...................................................c........................................ 333
Pakiet java.lang ...................................................c................................... 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
Pakiet java.net ...................................................c...................................... 336
Pakiet java.text (wprowadzony w JDK 1.1) ........................................... 336
Pakiet java.util ...................................................c..................................... 337
Pakiet java.util.jar (wprowadzony w JDK 1.2) ....................................... 337
Pakiet java.util.zip (wprowadzony w JDK 1.1) ...................................... 338
S
p
i
s
t
r
e
ś
c
i
Dodatek D Różnice pomiędzy JDK 1.0, 1.1, 1.2 i 1.3
339
„Stary” model zdarzeń ...................................................c......................... 340
Skorowidz
347
9
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.
P
o
d
e
j
m
o
w
a
n
i
e
d
e
c
y
z
j
i
85
f
i
—
e
w
o
k
n
u
r
a
w
e
j
c
k
u
r
t
s
n
I
Rozdział 6.
Instrukcje warunkowe — if
Listing HTML 6.1. Umieszcza aplet 6.1 w oknie
przeglądarki
Najprostszym sposobem przejęcie kontroli
nad działaniem apletu jest użycie instrukcji KH.
Działanie tej instrukcji można wyrazić słowami:
„Jeśli (KH) jakaś wartość jest prawdziwa (VTWG),
wówczas uruchom instrukcje znajdujące się
w nawiasach klamrowych. W przeciwnym
wypadku pomiń ten fragment kodu”. Listing
HTML 6.1 i aplet 6.1 pokazują, jak używać
instrukcji warunkowych w celu wyświetlenia
wpisanego przez użytkownika tekstu.
Aby skorzystać z instrukcji if,
należy wpisać:
1. KORQTVLCXCCYVGXGPV
Na początku musimy obsłużyć zdarzenia
generowane przez użytkownika. Konieczne
do tego będą klasy z pakietu LCXCCYVGXGPV,
które w tym kroku importujemy.
2. RWDNKEENCUU#RRNGVGZVGPFU#RRNGV
åKORNGOGPVU#EVKQP.KUVGPGT]
Nasza nowa klasa (nazwana #RRNGV) została
zdefiniowana jako rozszerzenia standardowej
klasy #RRNGV. Nowością w tej definicji jest
słowo kluczowe KORNGOGPVU#EVKQP.KUVGPGT.
Oznacza to, że nasz aplet będzie zdolny
do obsługi zdarzeń generowanych przez
użytkownika i będzie przez cały czas swojego
działania oczekiwał na jego konkretne
czynności. Tabela 6.1 przedstawia metody
służące do przechwytywania interakcji
z użytkownikiem dla poszczególnych
elementów.
3. 6GZV(KGNFKP(KGNF PGY6GZV(KGNF
(QPVH PGY(QPV
6KOGU4QOCP(QPV
å$1.
5VTKPIYRKUCP[6GMUV
Oto, jak tworzymy nowe zmienne:
pole tekstowe KP(KGNF, przeznaczone
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,
który będzie zawierał tekst wpisany przez
użytkownika i wypisywany później na ekranie
(na początku ustawiamy łańcuch jako pusty).
86
JVON
JGCF
VKVNG .KUVKPI VKVNG
JGCF
DQF[DIEQNQT YJKVG
QDLGEVENCUUKF ENUKF #
å$ ( YKFVJ JGKIJV
åEQFGV[RG CRRNKECVKQPLCXC
RCTCOPCOG EQFGXCNWG #RRNGVENCUU
RCTCOPCOG V[RGXCNWG CRRNKECVKQP
åZLCXCCRRNGV XGTUKQP
RCTCOPCOG UETKRVCDNGXCNWG HCNUG
GODGFV[RG CRRNKECVKQPZLCXCCRRNGV
åXGTUKQP EQFG #RRNGVENCUUYKFVJ
åJGKIJV UETKRVCDNG HCNUG
åRNWIKPURCIG JVVR LCXCUWPEQORTQFWEVU
åRNWIKPRNWIKPKPUVCNNJVON
GODGF
QDLGEV
DQF[
JVON
Aplet 6.1. Jeśli wpiszesz tekst do pola inField, Java
wyświetli go na ekranie
KORQTVLCXCCYV
KORQTVLCXCCRRNGV#RRNGV
KORQTVLCXCCYVGXGPV
RWDNKEENCUU#RRNGVGZVGPFU#RRNGVKORNGOGPVU
å#EVKQP.KUVGPGT]
6GZV(KGNFKP(KGNF PGY6GZV(KGNF
(QPVH PGY(QPV
6KOGU4QOCP(QPV$1.
5VTKPIYRKUCP[6GMUV
RWDNKEXQKFKPKV
]
UGV$CEMITQWPF
QNQTYJKVG
KP(KGNFCFF#EVKQP.KUVGPGT
VJKU
CFF
KP(KGNF
_
RWDNKEXQKFRCKPV
)TCRJKEUI ]
IUGV(QPV
H
KH
YRKUCP[6GMUV ]
IFTCY5VTKPI
9RKUCđGħ
YRKUCP[6GMUV
å
_
_
RWDNKEXQKFCEVKQP2GTHQTOGF
#EVKQP XGPVG ]
YRKUCP[6GMUV KP(KGNFIGV6GZV
TGRCKPV
_
_
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
odpowiednie zdarzenie w Javie (ang. event).
Druga linia spowoduje wyświetlenie pola
tekstowego w obszarze apletu.
5. KH
YRKUCP[6GMUV ]
IFTCY5VTKPI
9RKUCđGħ
åYRKUCP[6GMUV
_
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.
6. RWDNKEXQKFCEVKQP2GTHQTOGF
å
#EVKQP XGPVG ]
YRKUCP[6GMUV KP(KGNFIGV6GZV
TGRCKPV
_
Ponieważ dodaliśmy wcześniej
#EVKQP.KUVGPGT do pola tekstowego
KP(KGNF, metoda CEVKQP2GTHQTOGF
będzie obsługiwać wszystkie zdarzenia
wywołane przez użytkownika. Jedynym
możliwym zdarzeniem w tym aplecie jest
wpisanie tekstu w jedynym polu tekstowym.
Kiedy to się stanie, przypisujemy zmiennej
łańcuchowej YRKUCP[6GMUV dane z tego pola.
Następnie wywołujemy metodę TGRCKPV
,
która odświeża obszar apletu (efekt
możemy zobaczyć na rysunku 6.1).
87
I
n
s
t
r
u
k
c
j
e
w
a
r
u
n
k
o
w
e
—
i
f
Rysunek 6.1. Oto aplet wyświetlający wpisany
przez użytkownika tekst
Wskazówki
Jeśli programowałeś wcześniej w innych
językach, możesz sądzić, że konieczne
jest użycie instrukcji VJGP po instrukcji KH.
W Javie nie używa się tej instrukcji.
Bardzo często w programach Javy można
spotkać instrukcję KH poprzedzającą
pojedynczą, wciętą instrukcję
nie umieszczoną w nawiasach
klamrowych. Taka poprawna składnia
oznacza, że instrukcja warunkowa KH
dotyczy tylko jednej, następującej po niej
instrukcji. Dla zachowania przejrzystości
kodu, w książce tej zawsze będziemy
następujące po KH instrukcje umieszczać
w nawiasach klamrowych.
Rozdział 6.
Tabela 6.1. Zdarzenia w Javie
Interfejs
Komponenty
#EVKQP.KUVGPGT
$WVVQP (przycisk)
.KUV (lista)
6GZV(KGNF (pole tekstowe)
/GPW+VGO (element menu)
Metody
#EVKQP2GTHQTOGF
#FLWUVOGPV.KUVGPGT
5ETQNNDCT (pasek przewijania)
CFLWUVOGPV8CNWG JCPIGF
QORQPGPV.KUVGPGT
Wszystkie komponenty
QPVCKPGT.KUVGPGT
Wszystkie pojemniki
(QEWU.KUVGPGT
Wszystkie komponenty
EQORQPGPV*KFFGP
QORQPGPV/QXGF
EQORQPGPV4GUKGF
EQORQPGPV5JQYP
EQORQPGPV#FFGF
EQORQPGPV4GOQXGF
HQEWU)CKPGF
HQEWU.QUV
+VGO.KUVGPGT
JGEMDQZ (pole wyboru)
KVGO5VCVG JCPIGF
JGEM$QZ/GPW+VGO (pole wyboru elementu menu)
JQKEG (lista rozwijana)
+VGO5GNGEVCDNG (element możliwy do wybrania)
.KUV (lista)
-G[.KUVGPGT
Wszystkie komponenty
/QWUG.KUVGPGT
Wszystkie komponenty
/QWUG/QVKQP.KUVGPGT
Wszystkie komponenty
MG[2TGUUGF
MG[4GNGCUGF
MG[6[RGF
OQWUG NKEMGF
OQWUG PVGTGF
OQWUG ZKVGF
OQWUG2TGUUGF
OQWUG4GNGCUGF
OQWUG TCIIGF
OQWUG/QXGF
6GZV.KUVGPGT
6GZV QORQPGPV (komponent tekstowy)
VGZV8CNWG JCPIGF
f
i
—
e
w
o
k
n
u
r
a
w
e
j
c
k
u
r
t
s
n
I
9KPFQY.KUVGPGT
9KPFQY (okno)
YKPFQY#EVKXCVGF
YKPFQY NQUGF
YKPFQY NQUKPI
YKPFQY GCEVKXCVGF
YKPFQY GKEQPKHKGF
YKPFQY+EQPKHKGF
YKPFQY1RGPGF
88
Listing HTML 6.2. Wywołuje aplet 6.2 i umieszcza
go w oknie przeglądarki internetowej
Przechwytywanie błędów
Podejmowanie decyzji
JVON
JGCF
VKVNG .KUVKPI VKVNG
JGCF
DQF[DIEQNQT YJKVG
QDLGEVENCUUKF ENUKF #
å$ ( YKFVJ JGKIJV
åEQFGV[RG CRRNKECVKQPLCXC
RCTCOPCOG EQFGXCNWG #RRNGVENCUU
RCTCOPCOG V[RGXCNWG CRRNKECVKQP
åZLCXCCRRNGV XGTUKQP
RCTCOPCOG UETKRVCDNGXCNWG HCNUG
GODGFV[RG CRRNKECVKQPZLCXCCRRNGV
åXGTUKQP EQFG #RRNGVENCUUYKFVJ
åJGKIJV UETKRVCDNG HCNUG
åRNWIKPURCIG JVVR LCXCUWPEQORTQFWEVU
åRNWIKPRNWIKPKPUVCNNJVON
GODGF
QDLGEV
DQF[
JVON
Kiedy umożliwiasz użytkownikowi interakcję
z Twoim apletem, może się zdarzyć, że dane,
które poda, nie będą pasowały do założeń
Twojego programu. Listing HTML 6.2 i aplet
6.2 pokazują, jak przechwycić potencjalne
błędy, zanim spowodują poważne problemy
w działaniu apletu.
Aby przechwycić błędy, należy użyć:
1. 6GZV(KGNFRQNG ICF[YCPKC PGY
å6GZV(KGNF
KPVPCUVGRPC2TQDC
Powyżej definiujemy zmienną
RQNG ICF[YCPKC typu 6GZV(KGNF (pole
tekstowe o długości 5). Wykorzystamy
to pole do pobierania od użytkownika
zgadywanej liczby. Zmienna PCUVGRPC2TQDC
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. KPVUWMCPC.KEDC
KPV
LCXCNCPI
å/CVJTCPFQO
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.
P
r
z
e
c
h
w
y
t
y
w
a
n
i
e
b
ł
ę
d
ó
w
89
Rozdział 6.
3. 5VTKPIUVCVWU.KED[ PCUVGRPC2TQDC
åLGUVUWMCPæNKEDæ
IUGV(QPV
H
Wewnątrz metody RCKPV
zdefiniowaliśmy
nową zmienną łańcuchową: UVCVWU.KED[.
Przypisujemy jej wartość zmiennej
PCUVGRPC2TQDC z dołączonym komunikatem
o udanej próbie odgadnięcia liczby
(patrz rysunek 6.2). W drugiej instrukcji
ustawiamy czcionkę dla naszego apletu
(za pomocą zmiennej H).
4. KH
PCUVGRPC2TQDC UWMCPC.KEDC ]
UVCVWU.KED[ PCUVGRPC2TQDC
PKG
åLGUVUWMCPæNKEDæ
_
Oto nasza pierwsza instrukcja KH.
Sprawdzamy w niej, czy liczba będąca
wartością zmiennej PCUVGRPC2TQDC różni się
od wylosowanej wcześniej wartości
UWMCPC.KEDC; sprawdzamy zatem,
czy podana przez użytkownika liczba różni
się od wartości, którą próbuje odgadnąć.
Jeśli wynikiem porównania będzie VTWG
(użytkownikowi nie udało się odgadnąć
naszej liczby), zostanie uruchomiony
kod znajdujący się wewnątrz nawiasów
klamrowych. W przeciwnym wypadku,
ten fragment programu zostanie pominięty.
Jeśli użytkownik nie odgadł wylosowanej
liczby, ponownie ustawiamy zmienną
UVCVWU.KED[, tym razem z komunikatem
o nieudanej próbie (patrz rysunek 6.3).
w
ó
d
ę
ł
b
e
i
n
a
w
y
t
y
w
h
c
e
z
r
P
Aplet 6.2. Zagrajmy w grę „zgadnij, jaką sobie
wymyśliłem liczbę”
KORQTVLCXCCYV
KORQTVLCXCCRRNGV#RRNGV
KORQTVLCXCCYVGXGPV
RWDNKEENCUU#RRNGVGZVGPFU#RRNGVKORNGOGPVU
å#EVKQP.KUVGPGT]
6GZV(KGNFRQNG ICF[YCPKC PGY6GZV(KGNF
KPVPCUVGRPC2TQDC
KPVUWMCPC.KEDC
KPV
LCXCNCPI/CVJ
åTCPFQO
(QPVH PGY(QPV
6KOGU4QOCP(QPV$1.
å
RWDNKEXQKFKPKV
]
UGV$CEMITQWPF
QNQTYJKVG
RQNG ICF[YCPKCCFF#EVKQP.KUVGPGT
VJKU
CFF
RQNG ICF[YCPKC
_
RWDNKEXQKFRCKPV
)TCRJKEUI ]
5VTKPIUVCVWU.KED[ PCUVGRPC2TQDC
åLGUVUWMCPæNKEDæ
IUGV(QPV
H
KH
PCUVGRPC2TQDC UWMCPC.KEDC ]
UVCVWU.KED[ PCUVGRPC2TQDC
PKG
åLGUVUWMCPæNKEDæ
_
KH
PCUVGRPC2TQDC ]
UVCVWU.KED[ 1FICFPKLNKEDúQF
åFQ
_
IFTCY5VTKPI
UVCVWU.KED[
_
RWDNKEXQKFCEVKQP2GTHQTOGF
#EVKQP XGPVG ]
KH
GIGV5QWTEG
KPUVCPEGQH6GZV(KGNF ]
VT[]
PCUVGRPC2TQDC +PVGIGTRCTUG+PV
å
RQNG ICF[YCPKCIGV6GZV
_
ECVEJ
0WODGT(QTOCV ZEGRVKQPZ ]
PCUVGRPC2TQDC
_
TGRCKPV
_
_
_
90
Rysunek 6.2. Oto efekt, na który czekaliśmy
Rysunek 6.3. Musisz spróbować jeszcze raz
Rysunek 6.4. Jeśli wpiszesz coś innego niż liczbę,
zobaczysz taki komunikat
Podejmowanie decyzji
5. KH
PCUVGRPC2TQDC ]
UVCVWU.KED[ 1FICFPKLNKEDú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
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
liczby spoza przedziału).
7. RWDNKEXQKFCEVKQP2GTHQTOGF
å
#EVKQP XGPVG ]
KH
GIGV5QWTEG
KPUVCPEGQH
å6GZV(KGNF ]
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).
P
r
z
e
c
h
w
y
t
y
w
a
n
i
e
b
ł
ę
d
ó
w
91
Rozdział 6.
8. VT[]
PCUVGRPC2TQDC +PVGIGTRCTUG+PV
å
RQNG ICF[YCPKCIGV6GZV
_
ECVEJ
0WODGT(QTOCV ZEGRVKQPZ ]
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ć
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ść .
Niezależnie od rezultatu przekształcenia
wywołujemy metodę TGRCKPV
,
która przerysuje obszar apletu.
Wskazówka
Powyższy przykład nie prezentuje
najlepszego pomysłu na tego typu grę.
Średnio użytkownik musi 50 razy
spróbować szczęścia, zanim odgadnie
wylosowaną liczbę. W następnym
przykładzie zaprezentujemy dużo
ciekawsze rozwiązanie.
w
ó
d
ę
ł
b
e
i
n
a
w
y
t
y
w
h
c
e
z
r
P
92
Java odrzuca nasze polecenia
Wyjątki w Javie można wyrazić
przesłaniem od programu mówiącym
„zrób to inaczej”. Źródłem wyjątków są
nieprzewidziane i niechciane
zdarzenia. Przykładowo, Java nie
będzie w stanie zamienić liter na liczbę.
Kiedy Java wyzwala wyjątek, Ty,
programista, musisz go przechwycić.
Zrobisz to za pomocą słowa
kluczowego ECVEJ, po którym określisz,
co program Javy ma zrobić w razie
wystąpienia potencjalnych wyjątków.
Listing HTML 6.3. Wyświetla aplet 6.3 w oknie
przeglądarki internetowej
JVON
JGCF
VKVNG .KUVKPI VKVNG
JGCF
DQF[DIEQNQT YJKVG
QDLGEVENCUUKF ENUKF #
å$ ( YKFVJ JGKIJV
åEQFGV[RG CRRNKECVKQPLCXC
RCTCOPCOG EQFGXCNWG #RRNGVENCUU
RCTCOPCOG V[RGXCNWG CRRNKECVKQP
åZLCXCCRRNGV XGTUKQP
RCTCOPCOG UETKRVCDNGXCNWG HCNUG
GODGFV[RG CRRNKECVKQPZLCXCCRRNGV
åXGTUKQP EQFG #RRNGVENCUU
åYKFVJ JGKIJV UETKRVCDNG HCNUG
åRNWIKPURCIG JVVR LCXCUWPEQORTQFWEVU
åRNWIKPRNWIKPKPUVCNNJVON
GODGF
QDLGEV
DQF[
JVON
Podejmowanie decyzji
Więcej o instrukcjach
warunkowych — if…else
Niekiedy niezbędne jest jedynie wyrażenie
tego, co ma się stać, jeśli dane wyrażenie jest
prawdziwe. Czasem jednak będziesz chciał
wyznaczyć instrukcje, które powinny być
przetworzone, gdy warunek instrukcji KH nie
jest spełniony. Służy do tego instrukcja GNUG
wskazująca na blok kodu uruchamiany tylko
wtedy, gdy warunek instrukcji warunkowej
KHnie jest spełniony. Listing HTML 6.3 i aplet
6.3 prezentują poprawiony aplet gry „zgadnij,
jaką sobie wymyśliłem liczbę”, który prezentuje
użytkownikowi kierunek, w którym powinien
podążać.
Aby korzystać z konstrukcji if…else,
należy zastosować:
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[ 1FICFPKLNKEDú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”.
W
i
ę
c
e
j
o
i
n
s
t
r
u
k
c
j
a
c
h
w
a
r
u
n
k
o
w
y
c
h
93
Rozdział 6.
3. GNUG]
W przeciwnym wypadku, jeśli wartość
zmiennej PCUVGRPC2TQDC jest różna od
wartości zmiennej UWMCPC.KEDC oraz
PCUVGRPC2TQDC jest poprawną liczbą,
uruchamiamy fragment kodu poprzedzony
słowem GNUG. W tym przypadku fragment
składa się z kolejnego bloku KHŗGNUG.
4. KH
PCUVGRPC2TQDC UWMCPC.KEDC ]
UVCVWU.KED[ PCUVGRPC2TQDC
åVQCOCđQ
_
GNUG]
UVCVWU.KED[ PCUVGRPC2TQDC
åVQCFWľQ
_
Teraz sprawdzamy, czy wartość zmiennej
PCUVGRPC2TQDC jest mniejsza od wartości
przechowywanej w zmiennej UWMCPC.KEDC.
Jeśli tak, zmienna PCUVGRPC2TQDC będzie
wyświetlona z komunikatem, że podana
liczba jest za mała. W przeciwnym razie
zakomunikujemy użytkownikowi, że jest
za duża. Na rysunku 6.5 prezentujemy
wygląd apletu, gdy podana liczba jest
za duża, rysunki 6.6 i 6.7 prezentują efekt
dla zbyt małej liczby. Jeśli w końcu podamy
liczbę równą szukanej, zobaczymy
komunikat widoczny na rysunku 6.8.
h
c
y
w
o
k
n
u
r
a
w
h
c
a
j
c
k
u
r
t
s
n
i
o
j
e
c
ę
i
W
94
Aplet 6.3. Ulepszona wersja gry „zgadnij, jaką
sobie wymyśliłem liczbę”
KORQTVLCXCCYV
KORQTVLCXCCRRNGV#RRNGV
KORQTVLCXCCYVGXGPV
RWDNKEENCUU#RRNGVGZVGPFU#RRNGVKORNGOGPVU
å#EVKQP.KUVGPGT]
6GZV(KGNFRQNG ICF[YCPKC PGY6GZV(KGNF
KPVPCUVGRPC2TQDC
KPVUWMCPC.KEDC
KPV
LCXCNCPI/CVJ
åTCPFQO
(QPVH PGY(QPV
6KOGU4QOCP(QPV$1.
å
RWDNKEXQKFKPKV
]
UGV$CEMITQWPF
QNQTYJKVG
RQNG ICF[YCPKCCFF#EVKQP.KUVGPGT
VJKU
CFF
RQNG ICF[YCPKC
_
RWDNKEXQKFRCKPV
)TCRJKEUI ]
5VTKPIUVCVWU.KED[ PCUVGRPC2TQDC
åLGUVUWMCPæNKEDæ
IUGV(QPV
H
KH
PCUVGRPC2TQDC UWMCPC.KEDC ]
KH
PCUVGRPC2TQDC ]
UVCVWU.KED[ 1FICFPKLNKEDúQF
åFQ
_
GNUG]
KH
PCUVGRPC2TQDC UWMCPC.KEDC ]
UVCVWU.KED[ PCUVGRPC2TQDC
VQ
åCOCđQ
_
GNUG]
UVCVWU.KED[ PCUVGRPC2TQDC
VQ
åCFWľQ
_
_
_
IFTCY5VTKPI
UVCVWU.KED[
_
RWDNKEXQKFCEVKQP2GTHQTOGF
#EVKQP XGPVG ]
KH
GIGV5QWTEG
KPUVCPEGQH6GZV(KGNF ]
VT[]
PCUVGRPC2TQDC +PVGIGTRCTUG+PV
å
RQNG ICF[YCPKCIGV6GZV
_
ECVEJ
0WODGT(QTOCV ZEGRVKQPZ ]
PCUVGRPC2TQDC
_
TGRCKPV
_
_
_
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.
W
i
ę
c
e
j
o
i
n
s
t
r
u
k
c
j
a
c
h
w
a
r
u
n
k
o
w
y
c
h
Rysunek 6.5. Zaczniemy od liczby 50 i zobaczymy,
czy jest za duża czy za mała
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
Listing HTML 6.4. Oto, jak możemy wywołać nasz
nowy aplet
JVON
JGCF
VKVNG .KUVKPI VKVNG
JGCF
DQF[DIEQNQT YJKVG
QDLGEVENCUUKF ENUKF #
å$ ( YKFVJ JGKIJV
åEQFGV[RG CRRNKECVKQPLCXC
RCTCOPCOG EQFGXCNWG #RRNGVENCUU
RCTCOPCOG V[RGXCNWG CRRNKECVKQP
åZLCXCCRRNGV XGTUKQP
RCTCOPCOG UETKRVCDNGXCNWG HCNUG
GODGFV[RG CRRNKECVKQPZLCXCCRRNGV
åXGTUKQP EQFG #RRNGVENCUUYKFVJ
åJGKIJV UETKRVCDNG HCNUG
åRNWIKPURCIG JVVR LCXCUWPEQORTQFWEVU
åRNWIKPRNWIKPKPUVCNNJVON
GODGF
QDLGEV
DQF[
JVON
Rysunek 6.9. Użytkownik poprosił o 29 gwiazdek
i natychmiast je otrzymał
i
l
t
ę
p
ą
c
o
m
o
p
a
z
i
c
ś
o
n
n
y
z
c
e
i
n
a
z
r
a
t
w
o
P
Rozdział 6.
Powtarzanie czynności
za pomocą pętli
Struktura KHŗGNUG, którą posługiwaliśmy się
w poprzednim przykładzie, pozwalała uruchamiać
albo jeden, albo drugi blok kodu. W przyszłości
często możesz stawać przed koniecznością wpisania
jednej lub wielu instrukcji, które powinny być
uruchomione wielokrotnie. Rozwiązaniem, które
pozwala to zrealizować, jest pętla. Listing HTML
6.4 i aplet 6.4 demonstrują jeden z rodzajów pętli:
HQT. W poniższym przykładzie umożliwimy
użytkownikowi wpisanie liczby, na podstawie
której wyświetlimy rząd gwiazdek w oknie
przeglądarki.
Zapętlenie kodu
Pętla HQT składa się z trzech części (patrz
rysunek 6.10):
1. Inicjalizacja — podczas pierwszego
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
w pętli jako „mniejszy niż wartość
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
Aplet 6.4. Aplet „pyta” użytkownika o liczbę
gwiazdek i wyświetla je za pomocą pętli
Aby korzystać z pętli for,
należy zastosować:
Podejmowanie decyzji
KORQTVLCXCCYV
KORQTVLCXCCRRNGV#RRNGV
KORQTVLCXCCYVGXGPV
RWDNKEENCUU#RRNGVGZVGPFU#RRNGVKORNGOGPVU
å#EVKQP.KUVGPGT]
6GZV(KGNFRQNG7[VMQYPKMC PGY6GZV(KGNF
KPVNKEDC7[VMQYPKMC
(QPVH PGY(QPV
6KOGU4QOCP(QPV$1.
å
RWDNKEXQKFKPKV
]
UGV$CEMITQWPF
QNQTYJKVG
RQNG7[VMQYPKMCCFF#EVKQP.KUVGPGT
VJKU
CFF
RQNG7[VMQYPKMC
_
RWDNKEXQKFRCKPV
)TCRJKEUI ]
5VTKPINCPEWEJ9[LUEKQY[
KPVK
IUGV(QPV
H
KH
NKEDC7[VMQYPKMC ^^
åNKEDC7[VMQYPKMC ]
NCPEWEJ9[LUEKQY[ 2QFCLNKEDúQF
åFQ
_
GNUG]
HQT
K K NKEDC7[VMQYPKMC K
]
NCPEWEJ9[LUEKQY[ NCPEWEJ9[LUEKQY[
å
_
_
IFTCY5VTKPI
NCPEWEJ9[LUEKQY[
_
RWDNKEXQKFCEVKQP2GTHQTOGF
#EVKQP XGPVG ]
KH
GIGV5QWTEG
KPUVCPEGQH6GZV(KGNF ]
VT[]
NKEDC7[VMQYPKMC +PVGIGTRCTUG+PV
å
RQNG7[VMQYPKMCIGV6GZV
_
ECVEJ
0WODGT(QTOCV ZEGRVKQPZ ]
NKEDC7[VMQYPKMC
_
TGRCKPV
_
_
_
1. KH
NKEDC7[VMQYPKMC ^^
åNKEDC7[VMQYPKMC ]
NCPEWEJ9[LUEKQY[ 2QFCLNKEDúQF
åFQ
_
Na początku upewniamy się, czy użytkownik
wpisał liczbę mieszczącą się w założonym
przedziale (od 1 do 50).
2. GNUG]
HQT
K K NKEDC7[VMQYPKMC K
]
NCPEWEJ9[LUEKQY[ NCPEWEJ9[LUEKQY[
å
_
_
Jeśli liczba jest prawidłowa (nie spełniony
warunek instrukcji KH z poprzedniego kroku),
przechodzimy do pętli HQT. Pierwsza część
inicjalizuje licznik pętli K wartością .
W drugiej części określamy, że pętla będzie
działać tak długo, aż K będzie mniejsze
od wartości podanej przez użytkownika.
Trzeci element określa operację wykonywaną
przy każdej iteracji pętli, w tym przypadku
licznik pętli będzie zwiększany o .
Na rysunku 6.9 widać efekt działania
apletu po tym, jak użytkownik wpisał „29”.
Do zmiennej NCPEWEJ9[LUEKQY[ (początkowo
jest pustym łańcuchem) dodajemy gwiazdkę
przy każdym nawrocie pętli.
Wskazówka
Znaki ^^ pomiędzy warunkami
sprawdzającymi, czy NKEDC7[VMQYPKMC
jest mniejsza od 1 i większa niż 50
oznaczają logiczną alternatywę (czyli „lub”).
Mówi to, że cały warunek KH jest prawdziwy,
jeśli choć jeden z warunków składowych
(rozdzielonych ^^) jest prawdziwy.
Gdybyśmy chcieli, by konieczna
była prawdziwość oby warunków,
rozdzielilibyśmy je znakami
oznaczającymi koniunkcję (czyli „i”).
97
P
o
w
t
a
r
z
a
n
i
e
c
z
y
n
n
o
ś
c
i
z
a
p
o
m
o
c
ą
p
ę
t
l
i
e
l
i
h
w
—
i
l
t
ę
p
j
a
z
d
o
r
y
n
n
I
Rozdział 6.
Inny rodzaj pętli — while
Listing HTML 6.5. Wstawia aplet 6.5 na stronę WWW
W Javie istnieją trzy sposoby budowania pętli.
Pierwszym jest pętla omówiona w poprzednim
przykładzie — pętla HQT, dwie pozostałe
to odmiany pętli YJKNG. Kod zawarty w pętli
YJKNG działa tak długo, jak długo spełniony
jest warunek tej pętli (patrz listing HTML 6.5
i aplet 6.5). Przy pierwszym sprawdzeniu tego
warunku, które wykaże jego nieprawdziwość,
działanie pętli jest kończone. Jeśli już przy
pierwszym sprawdzeniu, warunek okaże się
nieprawdziwy, pętla w ogóle nie zostanie
uruchomiona.
JVON
JGCF
VKVNG .KUVKPI VKVNG
JGCF
DQF[DIEQNQT YJKVG
QDLGEVENCUUKF ENUKF #
å$ ( YKFVJ JGKIJV
åEQFGV[RG CRRNKECVKQPLCXC
RCTCOPCOG EQFGXCNWG #RRNGVENCUU
RCTCOPCOG V[RGXCNWG CRRNKECVKQP
åZLCXCCRRNGV XGTUKQP
RCTCOPCOG UETKRVCDNGXCNWG HCNUG
GODGFV[RG CRRNKECVKQPZLCXCCRRNGV
åXGTUKQP EQFG #RRNGVENCUUYKFVJ
åJGKIJV UETKRVCDNG HCNUG
åRNWIKPURCIG JVVR LCXCUWPEQORTQFWEVU
åRNWIKPRNWIKPKPUVCNNJVON
GODGF
QDLGEV
DQF[
JVON
Rysunek 6.11. Teraz użytkownik poprosił jedynie
o trzy gwiazdki
98
Podejmowanie decyzji
Aby używać pętli while, należy wpisać:
1. YJKNG
K NKEDC7[VMQYPKMC
NCPEWEJ9[LUEKQY[ NCPEWEJ9[LUEKQY[
å
K
_
Wartość zmiennej NKEDC7[VMQYPKMC
albo mieści się w przedziale od 1 do 50
(wówczas jest prawidłowa), albo wynosi
(jeśli użytkownik wpisał niepoprawny
łańcuch). Ponieważ K jest inicjalizowane
wartością , powyższa pętla w ogóle
nie zadziała, jeśli nie podano prawidłowej
wartości, ponieważ nie jest większe od .
Jeśli podana przez użytkownika wartość
jest prawidłowa, kod zawarty w pętli zostanie
przetworzony tyle razy, ile przypisano
zmiennej NKEDC7[VMQYPKMC. Za każdym
razem zmienna K jest zwiększana o 1.
Przykładowo, jeśli wartość zmiennej
NKEDC7[VMQYPKMC wynosi , pętla
uruchomi się 25 razy. Jeśli NKEDC7[VMQYPKMC
wynosi , pętla YJKNG przed pierwszym
uruchomieniem stwierdzi nieprawdziwość
warunku K NKEDC7[VMQYPKMC
i nie uruchomi się ani razu.
Wskazówka
Upewnij się, że pętla YJKNG kiedyś się
zakończy. Gdybyś, przykładowo, pominął
instrukcję K
w powyższym przykładzie,
stworzył byś nieskończoną pętlę, czyli taką,
która sama nigdy się nie zakończy.
Aplet 6.5. Ciekawe, ile gwiazdek użytkownik będzie
chciał wyświetlić tym razem
KORQTVLCXCCYV
KORQTVLCXCCRRNGV#RRNGV
KORQTVLCXCCYVGXGPV
RWDNKEENCUU#RRNGVGZVGPFU#RRNGV
åKORNGOGPVU#EVKQP.KUVGPGT]
6GZV(KGNFRQNG7[VMQYPKMC PGY6GZV(KGNF
KPVNKEDC7[VMQYPKMC
(QPVH PGY(QPV
6KOGU4QOCP(QPV$1.
å
RWDNKEXQKFKPKV
]
UGV$CEMITQWPF
QNQTYJKVG
RQNG7[VMQYPKMCCFF#EVKQP.KUVGPGT
VJKU
CFF
RQNG7[VMQYPKMC
_
RWDNKEXQKFRCKPV
)TCRJKEUI ]
5VTKPINCPEWEJ9[LUEKQY[
KPVK
IUGV(QPV
H
KH
NKEDC7[VMQYPKMC ]
NKEDC7[VMQYPKMC
_
KH
NKEDC7[VMQYPKMC ]
NCPEWEJ9[LUEKQY[ 2QFCLNKEDúQF
åFQ
_
YJKNG
K NKEDC7[VMQYPKMC ]
NCPEWEJ9[LUEKQY[ NCPEWEJ9[LUEKQY[
K
_
IFTCY5VTKPI
NCPEWEJ9[LUEKQY[
_
RWDNKEXQKFCEVKQP2GTHQTOGF
#EVKQP XGPVG ]
KH
GIGV5QWTEG
KPUVCPEGQH6GZV(KGNF ]
VT[]
NKEDC7[VMQYPKMC +PVGIGTRCTUG+PV
å
RQNG7[VMQYPKMCIGV6GZV
_
ECVEJ
0WODGT(QTOCV ZEGRVKQPZ ]
NKEDC7[VMQYPKMC
_
TGRCKPV
_
_
_
99
I
n
n
y
r
o
d
z
a
j
p
ę
t
l
i
—
w
h
i
l
e
Rozdział 6.
Ostatni rodzaj pętli
— do…while
Trzecim i ostatnim typem pętli w Javie jest
FQŗYJKNG. W układzie FQŗYJKNG sprawdzamy
warunek pętli na końcu pętli, a nie na początku.
Oznacza to, że pętla zawsze się uruchomi
przynajmniej raz. Listing HTML 6.6 i aplet 6.6
prezentują zastosowanie pętli FQŗYJKNG.
Aby użyć pętli do…while,
należy wpisać:
1. FQ]
NCPEWEJ9[LUEKQY[ NCPEWEJ9[LUEKQY[
å
K
_YJKNG
K NKEDC7[VMQYPKMC
W takim układzie zmienna łańcuchowa
NCPEWEJ9[LUEKQY[ będzie zawsze zawierała
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
Kbędzie mniejsze od NKEDC7[VMQYPKMC.
Efekt widać na rysunku 6.12.
e
l
i
h
w
…
o
d
—
i
l
t
ę
p
j
a
z
d
o
r
i
n
t
a
t
s
O
Listing HTML 6.6. Poniższy plik HTML wywołuje
aplet 6.6 zawierający pętlę do…while
JVON
JGCF
VKVNG .KUVKPI VKVNG
JGCF
DQF[DIEQNQT YJKVG
QDLGEVENCUUKF ENUKF #
å$ ( YKFVJ JGKIJV
åEQFGV[RG CRRNKECVKQPLCXC
RCTCOPCOG EQFGXCNWG #RRNGVENCUU
RCTCOPCOG V[RGXCNWG CRRNKECVKQP
åZLCXCCRRNGV XGTUKQP
RCTCOPCOG UETKRVCDNGXCNWG HCNUG
GODGFV[RG CRRNKECVKQPZLCXCCRRNGV
åXGTUKQP EQFG #RRNGVENCUUYKFVJ
åJGKIJV UETKRVCDNG HCNUG
åRNWIKPURCIG JVVR LCXCUWPEQORTQFWEVU
åRNWIKPRNWIKPKPUVCNNJVON
GODGF
QDLGEV
DQF[
JVON
Rysunek 6.12. Użytkownik zażądał 34 gwiazdki
100
Aplet 6.6. Za pomocą pętli do…while przetwarzamy
żądanie użytkownika
KORQTVLCXCCYV
KORQTVLCXCCRRNGV#RRNGV
KORQTVLCXCCYVGXGPV
RWDNKEENCUU#RRNGVGZVGPFU#RRNGVKORNGOGPVU
å#EVKQP.KUVGPGT]
6GZV(KGNFRQNG7[VMQYPKMC PGY6GZV(KGNF
KPVNKEDC7[VMQYPKMC
(QPVH PGY(QPV
6KOGU4QOCP(QPV$1.
å
RWDNKEXQKFKPKV
]
UGV$CEMITQWPF
QNQTYJKVG
RQNG7[VMQYPKMCCFF#EVKQP.KUVGPGT
VJKU
CFF
RQNG7[VMQYPKMC
_
RWDNKEXQKFRCKPV
)TCRJKEUI ]
5VTKPINCPEWEJ9[LUEKQY[
KPVK
IUGV(QPV
H
KH
NKEDC7[VMQYPKMC ^^
åNKEDC7[VMQYPKMC ]
NCPEWEJ9[LUEKQY[ 2QFCLNKEDúQF
åFQ
_
GNUG]
FQ]
NCPEWEJ9[LUEKQY[ NCPEWEJ9[LUEKQY[
å
K
_YJKNG
K NKEDC7[VMQYPKMC
_
IFTCY5VTKPI
NCPEWEJ9[LUEKQY[
_
RWDNKEXQKFCEVKQP2GTHQTOGF
#EVKQP XGPVG ]
KH
GIGV5QWTEG
KPUVCPEGQH6GZV(KGNF ]
VT[]
NKEDC7[VMQYPKMC +PVGIGTRCTUG+PV
å
RQNG7[VMQYPKMCIGV6GZV
_
ECVEJ
0WODGT(QTOCV ZEGRVKQPZ ]
NKEDC7[VMQYPKMC
_
TGRCKPV
_
_
_
Podejmowanie decyzji
O
s
t
a
t
n
i
r
o
d
z
a
j
p
ę
t
l
i
—
d
o
…
w
h
i
l
e
101
Rozdział 6.
Przerywanie działania pętli
Listing HTML 6.7. Wstawia na stronę aplet 6.7
Istnieje możliwość opuszczenia pętli
przetwarzanej zgodnie z jej warunkami.
Taki sposób kończenia pętli można uzyskać
za pomocą instrukcji DTGCM.
W listingu HTML 6.7 i aplecie 6.7 użytkownik
może wpisać dowolną liczbę. Niezależnie
jednak od jej wielkości, pętla nie zadziała
więcej niż dwadzieścia razy.
Aby przerwać działanie pętli,
należy użyć:
1. HQT
K K NKEDC7[VMQYPKMC K
]
KH
K DTGCM
NCPEWEJ9[LUEKQY[ NCPEWEJ9[LUEKQY[
å
_
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 Kosią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.
i
l
t
ę
p
a
i
n
a
ł
a
i
z
d
e
i
n
a
w
y
r
e
z
r
P
JVON
JGCF
VKVNG .KUVKPI VKVNG
JGCF
DQF[DIEQNQT YJKVG
QDLGEVENCUUKF ENUKF #
å$ ( YKFVJ JGKIJV
åEQFGV[RG CRRNKECVKQPLCXC
RCTCOPCOG EQFGXCNWG #RRNGVENCUU
RCTCOPCOG V[RGXCNWG CRRNKECVKQP
åZLCXCCRRNGV XGTUKQP
RCTCOPCOG UETKRVCDNGXCNWG HCNUG
GODGFV[RG CRRNKECVKQPZLCXCCRRNGV
åXGTUKQP EQFG #RRNGVENCUUYKFVJ
åJGKIJV UETKRVCDNG HCNUG
åRNWIKPURCIG JVVR LCXCUWPEQORTQFWEVU
åRNWIKPRNWIKPKPUVCNNJVON
GODGF
QDLGEV
DQF[
JVON
Rysunek 6.13. Niezależnie od tego, jaką liczbę
podamy, zobaczymy maksymalnie 20 gwiazdek
102
Aplet 6.7. Demonstruje opuszczenie pętli za pomocą
instrukcji break
KORQTVLCXCCYV
KORQTVLCXCCRRNGV#RRNGV
KORQTVLCXCCYVGXGPV
RWDNKEENCUU#RRNGVGZVGPFU#RRNGVKORNGOGPVU
å#EVKQP.KUVGPGT]
6GZV(KGNFRQNG7[VMQYPKMC PGY6GZV(KGNF
KPVNKEDC7[VMQYPKMC
(QPVH PGY(QPV
6KOGU4QOCP(QPV$1.
å
RWDNKEXQKFKPKV
]
UGV$CEMITQWPF
QNQTYJKVG
RQNG7[VMQYPKMCCFF#EVKQP.KUVGPGT
VJKU
CFF
RQNG7[VMQYPKMC
_
RWDNKEXQKFRCKPV
)TCRJKEUI ]
5VTKPINCPEWEJ9[LUEKQY[
KPVK
IUGV(QPV
H
KH
NKEDC7[VMQYPKMC ]
NCPEWEJ9[LUEKQY[ 2QFCLNKEDúQF
åFQ
_
GNUG]
HQT
K K NKEDC7[VMQYPKMC K
]
KH
K DTGCM
NCPEWEJ9[LUEKQY[ NCPEWEJ9[LUEKQY[
å
_
_
IFTCY5VTKPI
NCPEWEJ9[LUEKQY[
_
RWDNKEXQKFCEVKQP2GTHQTOGF
#EVKQP XGPVG ]
KH
GIGV5QWTEG
KPUVCPEGQH6GZV(KGNF ]
VT[]
NKEDC7[VMQYPKMC +PVGIGTRCTUG+PV
å
RQNG7[VMQYPKMCIGV6GZV
_
ECVEJ
0WODGT(QTOCV ZEGRVKQPZ ]
NKEDC7[VMQYPKMC
_
TGRCKPV
_
_
_
Podejmowanie decyzji
Wskazówka
W Javie istnieje także instrukcja EQPVKPWG.
Kiedy jej użyjemy, następujący po niej
fragment kodu wewnątrz pętli zostanie
pominięty, nie przerywamy jednak jej
działania. W powyższym przypadku,
gdybyśmy zastąpili instrukcję DTGCM
instrukcją EQPVKPWG, pomijane byłyby
instrukcje dopisywania gwiazdki do
zmiennej NCPEWEJ9[LUEKQY[ od momentu
osiągnięcia przez K wartości .
W przeciwieństwie jednak do przerwania
działania pętli instrukcją DTGCM, gdybyśmy
użyli EQPVKPWG, pętla działałaby nadal,
aż do momentu zrównania się licznika K
z wartością zmiennej NKEDC7[VMQYPKMC.
P
r
z
e
r
y
w
a
n
i
e
d
z
i
a
ł
a
n
i
a
p
ę
t
l
i
103
Rozdział 6.
Konstrukcja switch…case
Listing HTML 6.8. Tak wstawiamy naszą grę
zapisaną w aplecie 6.8
JVON
JGCF
VKVNG .KUVKPI VKVNG
JGCF
DQF[DIEQNQT YJKVG
QDLGEVENCUUKF ENUKF #
å$ ( YKFVJ JGKIJV
åEQFGV[RG CRRNKECVKQPLCXC
RCTCOPCOG EQFGXCNWG #RRNGVENCUU
RCTCOPCOG V[RGXCNWG CRRNKECVKQP
åZLCXCCRRNGV XGTUKQP
RCTCOPCOG UETKRVCDNGXCNWG HCNUG
GODGFV[RG CRRNKECVKQPZLCXCCRRNGV
åXGTUKQP EQFG #RRNGVENCUUYKFVJ
åJGKIJV UETKRVCDNG HCNUG
åRNWIKPURCIG JVVR LCXCUWPEQORTQFWEVU
åRNWIKPRNWIKPKPUVCNNJVON
GODGF
QDLGEV
DQF[
e
s
a
c
…
h
c
e
s
a
c
…
h
c
t
i
w
s
a
j
c
k
u
r
t
s
n
o
K
Java oferuje jeszcze jeden sposób kontrolowania
przetwarzania kodu — konstrukcję UYKVEJŗECUG.
Najprostszym sposobem zrozumienia istoty
tej instrukcji jest spojrzenie na nią jak na zbiór
instrukcji KHŗGNUG. Zamiast powiedzieć: „jeśli
dzisiaj jest poniedziałek, zrób to; w przeciwnym
razie, jeśli dzisiaj jest wtorek, zrób coś innego;
w przeciwnym razie, jeśli dzisiaj jest środa,
zrób coś jeszcze innego itd.”, możemy użyć
konstrukcji UYKVEJŗECUG, by bezpośrednio
wyróżnić każdą z możliwości.
Listing HTML 6.8 i aplet 6.8 prezentują grę
w kamień, nożyce i papier napisaną z użyciem
konstrukcji UYKVEJŗECUG.
Aby użyć instrukcji switch…case,
należy zastosować:
1. RWDNKEENCUU#RRNGVGZVGPFU#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)TQWRWUGT JGEMDQZ
JGEMDQZMCOKGP JGEM$QZPQ[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
Aplet 6.8. Zobaczmy, czy możemy wygrać
z naszym apletem
KORQTVLCXCCYV
KORQTVLCXCCRRNGV#RRNGV
KORQTVLCXCCYVGXGPV
RWDNKEENCUU#RRNGVGZVGPFU#RRNGVKORNGOGPVU
å+VGO.KUVGPGT]
KPVNKEDC#RNGVW
KPV
LCXCNCPI/CVJ
åTCPFQO
(QPVH PGY(QPV
6KOGU4QOCP(QPV$1.
å
JGEMDQZ)TQWRWUGT JGEMDQZ
JGEMDQZMCOKGP JGEM$QZPQ[EG JGEM$QZ
åRCRKGT JGEM$QZ
DQQNGCPRKGTYUC2TQDC VTWG
5VTKPIY[DQT7[VMQYPKMC
RWDNKEXQKFKPKV
]
UGV$CEMITQWPF
QNQTYJKVG
WUGT JGEMDQZ PGY JGEMDQZ)TQWR
MCOKGP JGEM$QZ PGY JGEMDQZ
-COKGē
åWUGT JGEMDQZHCNUG
MCOKGP JGEM$QZCFF+VGO.KUVGPGT
VJKU
CFF
MCOKGP JGEM$QZ
PQ[EG JGEM$QZ PGY JGEMDQZ
0Qľ[EG
åWUGT JGEMDQZHCNUG
PQ[EG JGEM$QZCFF+VGO.KUVGPGT
VJKU
CFF
PQ[EG JGEM$QZ
RCRKGT JGEM$QZ PGY JGEMDQZ
2CRKGT
åWUGT JGEMDQZHCNUG
RCRKGT JGEM$QZCFF+VGO.KUVGPGT
VJKU
CFF
RCRKGT JGEM$QZ
_
RWDNKEXQKFRCKPV
)TCRJKEUI ]
KPVNKEDC7[VMQYPKMC
5VTKPIY[DQT#RNGVW
IUGV(QPV
H
KH
RKGTYUC2TQDC ]
IFTCY5VTKPI
CITCLGOPæYMCOKGē
åPQľ[EGKRCRKGT
RKGTYUC2TQDC HCNUG
_
GNUG]
UYKVEJ
NKEDC#RNGVW ]
ECUG
Y[DQT#RNGVW -COKGē
DTGCM
ECUG
Y[DQT#RNGVW 0Qľ[EG
DTGCM
Podejmowanie decyzji
4. MCOKGP JGEM$QZ PGY JGEMDQZ
-COKGē
åWUGT JGEMDQZHCNUG
MCOKGP JGEM$QZCFF+VGO.KUVGPGT
VJKU
åCFF
MCOKGP JGEM$QZ
Te trzy instrukcje tworzą przycisk opcji
MCOKGP JGEM$QZ będący częścią grupy
WUGT JGEMDQZ. Klikając którykolwiek
przycisk należący do tej grupy, spowodujesz,
że wszystkie pozostałe przyciski z tej grupy
zostaną wyłączone. Pierwszym parametrem
metody JGEMDQZ
jest etykieta (nazwa
przycisku wypisana na ekranie), drugim
parametrem jest wspomniana grupa
przycisków, jako trzeci parametr podajemy
stan przycisku (VTWG lub HCNUG, zależnie
od tego, czy chcemy, by był na początku
włączony czy wyłączony). Następnie
ustawiamy CFF+VGO.KUVGPGT
VJKU
dla nowego przycisku opcji, co pozwoli
nam dalej przechwytywać zdarzenia
związane z przyciskiem za pomocą metody
KVGO5VCVG JCPIGF
. Kończymy ten fragment
kodu, wstawiając nasz przycisk opcji
w obszarze apletu.
5. UYKVEJ
NKEDC#RNGVW ]
ECUG
Y[DQT#RNGVW -COKGē
DTGCM
ECUG
Y[DQT#RNGVW 0Qľ[EG
DTGCM
ECUG
Y[DQT#RNGVW 2CRKGT
DTGCM
FGHCWNV
Y[DQT#RNGVW $đæF
_
Podobnie jak we wcześniejszych
przykładach, użyliśmy generatora liczb
losowych Javy do przypadkowego wybrania
kamienia, nożyc lub papieru przez nasz
aplet. W efekcie zmienna NKEDC#RNGVW
zawiera liczbę losową od 1 do 3. Teraz
instrukcja UYKVEJ
wybiera odpowiedni
blok kodu ECUG w zależności od wartości
zmiennej NKEDC#RNGVW. Powyższy fragment
moglibyśmy zapisać następująco:
105
J
V
O
N
K
o
n
s
t
r
u
k
c
j
a
s
w
i
t
c
h
c
a
s
e
e
s
a
c
…
h
c
t
i
w
s
a
j
c
k
u
r
t
s
n
o
K
Rozdział 6.
KH
NKEDC#RNGVW ]
Y[DQT#RNGVW -COKGē
_
GNUG
KH
NKEDC#RNGVW ]
Y[DQT#RNGVW 0Qľ[EG
_
GNUG
KH
I tak dalej, dla każdej możliwej wartości.
6. UYKVEJ
Y[DQT7[VMQYPKMCEJCT#V
]
ECUG -
NKEDC7[VMQYPKMC
DTGCM
ECUG 0
NKEDC7[VMQYPKMC
DTGCM
ECUG 2
NKEDC7[VMQYPKMC
DTGCM
FGHCWNV
NKEDC7[VMQYPKMC
_
W tym fragmencie kodu sprawdzamy
zmienną typu EJCT (podobny typ
do łańcucha, tyle że przechowujący tylko
jeden znak), a nie, jak poprzednio, liczbę.
Użytkownik dokonuje wyboru, klikając
przycisk opcji, co wyzwala zdarzenie Javy.
Możemy odczytać etykietę klikniętego
przycisku i przypisać zmiennej
całkowitoliczbowej NKEDC7[VMQYPKMC
odpowiednią wartość w celu późniejszego
porównania z wyborem apletu (zmienna
NKEDC#RNGVW). Rysunek 6.14 prezentuje
widok apletu na początku gry. Rysunki 6.15,
6.16 i 6.17 prezentują możliwe wyniki.
7. RWDNKEXQKFKVGO5VCVG JCPIGF
+VGO XGPVG ]
KH
GIGV5QWTEG
KPUVCPEGQH JGEMDQZ ]
Y[DQT7[VMQYPKMC WUGT JGEMDQZ
åIGV5GNGEVGF JGEMDQZ
IGV.CDGN
Oto fragment kodu wyzwalany kliknięciem
myszą przez użytkownika. Jeśli obiektem
interakcji był przycisk opcji, zmiennej
Y[DQT7[VMQYPKMC przypisujemy etykietę
tego przycisku.
106
Aplet 6.8. Zobaczmy, czy możemy wygrać z naszym
apletem — ciąg dalszy
ECUG
Y[DQT#RNGVW 2CRKGT
DTGCM
FGHCWNV
Y[DQT#RNGVW $đæF
_
UYKVEJ
Y[DQT7[VMQYPKMCEJCT#V
]
ECUG -
NKEDC7[VMQYPKMC
DTGCM
ECUG 0
NKEDC7[VMQYPKMC
DTGCM
ECUG 2
NKEDC7[VMQYPKMC
DTGCM
FGHCWNV
NKEDC7[VMQYPKMC
_
KH
NKEDC#RNGVW NKEDC7[VMQYPKMC ]
IFTCY5VTKPI
4 /+5CITCLO[LGUEG
åTC
_
GNUG]
KH
NKEDC7[VMQYPKMC
åNKEDC#RNGVW ^^
å
NKEDC7[VMQYPKMC
åNKEDC#RNGVW ^^
å
NKEDC7[VMQYPKMC
åNKEDC#RNGVW ]
IFTCY5VTKPI
9[ITCđGO9[DTCđGO
å
Y[DQT#RNGVW
_
GNUG]
IFTCY5VTKPI
9[ITCđGħ9[DTCđGO
å
Y[DQT#RNGVW
_
_
IFTCY5VTKPI
#D[CITCèRQPQYPKG
åQFħYKGľVúUVTQPú
_
_
RWDNKEXQKFKVGO5VCVG JCPIGF
+VGO XGPVG ]
KH
GIGV5QWTEG
KPUVCPEGQH JGEMDQZ ]
Y[DQT7[VMQYPKMC WUGT JGEMDQZ
åIGV5GNGEVGF JGEMDQZ
IGV.CDGN
TGRCKPV
_
_
_
Podejmowanie decyzji
Wskazówki
Instrukcja UYKVEJŗECUG może być używana
jedynie dla czterech typów prymitywów:
D[VG, EJCT, KPV i UJQTV. Właśnie dlatego
w szóstym kroku sprawdzamy jedynie
pierwszą literę zmiennej łańcuchowej
Y[DQT7[VMQYPKMC zamiast całego łańcucha.
Gdybyśmy pominęli którąkolwiek
instrukcję DTGCM w powyższych blokach
ECUG, przetwarzane byłyby także następne
bloki ECUG. Przerywanie wykonania
instrukcji UYKVEJŗECUG jest bardzo
przydatne, może jednak być źródłem
wielu błędów w oprogramowaniu.
Pamiętaj więc o wstawianiu instrukcji
DTGCM na końcu każdego bloku ECUG.
Jeśli żadna z wartości wymienionych
w instrukcjach ECUG nie pasuje do wzorca,
przetwarzany jest blok domyślny
(rozpoczynający się od słowa FGHCWNV).
Nawet kiedy jesteś przekonany o tym,
że któraś z opcji musi zostać wybrana,
dla pewności używaj bloku FGHCWNV.
K
o
n
s
t
r
u
k
c
j
a
s
w
i
t
c
h
…
c
a
s
e
Rysunek 6.14. Aplet jest gotowy do nowej gry
Rysunek 6.15. Użytkownik wygrał pierwszą grę
Rysunek 6.16. W drugiej grze nastąpił remis
Rysunek 6.17. Ostatnią grę wygrał komputer
107
Pobierz darmowy fragment (pdf)
