Po prostu Java 2
-
Upload
wydawnictwo-helion -
Category
Documents
-
view
2.844 -
download
3
description
Transcript of Po prostu Java 2
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: [email protected]
PRZYK£ADOWY ROZDZIA£PRZYK£ADOWY ROZDZIA£
IDZ DOIDZ DO
ZAMÓW DRUKOWANY KATALOGZAMÓW DRUKOWANY KATALOG
KATALOG KSI¥¯EKKATALOG KSI¥¯EK
TWÓJ KOSZYKTWÓJ KOSZYK
CENNIK I INFORMACJECENNIK I INFORMACJE
ZAMÓW INFORMACJEO NOWO�CIACH
ZAMÓW INFORMACJEO NOWO�CIACH
ZAMÓW CENNIKZAMÓW CENNIK
CZYTELNIACZYTELNIA
FRAGMENTY KSI¥¯EK ONLINEFRAGMENTY KSI¥¯EK ONLINE
SPIS TRE�CISPIS TRE�CI
DODAJ DO KOSZYKADODAJ DO KOSZYKA
KATALOG ONLINEKATALOG ONLINE
Po prostu Java 2
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
5
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
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
Spis treści
Spis treści
6
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
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
Spis treści
7
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
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
Spis treści
8
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
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
Spis treści
9
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
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
Podejmowanie decyzji
85
Podejmowanie decyzjiNie zawsze aplety Javy przechodzą najprostsządrogę od pierwszej do ostatniej instrukcji.Niekiedy potrzebne jest ominięcie fragmentukodu, czy też powtórne uruchomienie pewnychinstrukcji. Wpływanie na przebieg działaniaprogramu nazywa się sterowaniem przepływem(ang. flow control). W tym rozdziale omówimy,jak zapanować nad kierunkiem przetwarzaniaTwojego kodu.
Podejmowanie decyzji
Podejm
ow
anie
decy
zji
Rozdział 6.
86
Instrukcje warunkowe — if
Najprostszym sposobem przejęcie kontrolinad działaniem apletu jest użycie instrukcji ��.Działanie tej instrukcji można wyrazić słowami:„Jeśli (��) jakaś wartość jest prawdziwa (����),wówczas uruchom instrukcje znajdujące sięw nawiasach klamrowych. W przeciwnymwypadku pomiń ten fragment kodu”. ListingHTML 6.1 i aplet 6.1 pokazują, jak używaćinstrukcji warunkowych w celu wyświetleniawpisanego przez użytkownika tekstu.
Aby skorzystać z instrukcji if,należy wpisać:
1. ������� ������� ������
Na początku musimy obsłużyć zdarzeniagenerowane przez użytkownika. Koniecznedo tego będą klasy z pakietu �� ������� ���,które w tym kroku importujemy.
2. ��������������������������������������������������������
Nasza nowa klasa (nazwana �������) zostałazdefiniowana jako rozszerzenia standardowejklasy ������. Nowością w tej definicji jestsłowo kluczowe �����������������������.Oznacza to, że nasz aplet będzie zdolnydo obsługi zdarzeń generowanych przezużytkownika i będzie przez cały czas swojegodziałania oczekiwał na jego konkretneczynności. Tabela 6.1 przedstawia metodysłużące do przechwytywania interakcjiz użytkownikiem dla poszczególnychelementów.
3. ����������������������������� �!"������������ #�����$���#%�����&'�(%!)"*����+������,��-���##�
Oto, jak tworzymy nowe zmienne:pole tekstowe �������, przeznaczonedo wpisywania znaków przez użytkownika,zmienną czcionki �, którą ustawiamyna rozmiar 24-punktowy i pogrubiony krójTimes Roman, oraz łańcuch ������,��-��,który będzie zawierał tekst wpisany przezużytkownika i wypisywany później na ekranie(na początku ustawiamy łańcuch jako pusty).
Inst
rukcj
e w
aru
nkow
e —
if
Listing HTML 6.1. Umieszcza aplet 6.1 w oknie
przeglądarki
�������������������� ��������������������������������������������������� ����� ���� !"�#$%$##&%�� �%�'(&!%$$�$)*#!! !(�������)$$����������$$�������+����++�����������,����+��������������,��-����++�������� ���+������������+��,��-����++����������.%��,�%�++���/,�� ������(���+���������� ���+������,��-���0�� ����������+����++���������.%��,�%�++���/�,�� ������(�������++�������� ��������)$$����������$$� ���+�������0�� ���+�-��� +��������+�����,�� -������+��-�� ��+�-������(�+�-���%�� ����������������������������������������
Aplet 6.1. Jeśli wpiszesz tekst do pola inField, Javawyświetli go na ekranie
��+�����,������1/��+�����,���++�����++���/������������ �����
���������������� ��� �� �������� ������ � �������������� � ������ ���� ������� ������ ��� ���� ���� !��������"���� �������#��� �$���#%������&'�(%� )!���*����+������,� -�����##�
+-����,������234 ��'��5���-�2"����������3/�������� ��������������� � ���.��!������������ ��!�6
+-����,��+����27��+��� �34�� ��*���203/�����"�������,� -���/��##!��������+����*����+�#0���1 23�#�4������,� -��%������� 5%�65!�66
������������������7 �"��� ��������8 ��� !�����������,� -��������� ���+ �� ���!������ �����!���96
Podejmowanie decyzji
87
Rysunek 6.1. Oto aplet wyświetlający wpisany
przez użytkownika tekst
Wskazówki
� Jeśli programowałeś wcześniej w innychjęzykach, możesz sądzić, że koniecznejest użycie instrukcji �.�� po instrukcji ��.W Javie nie używa się tej instrukcji.
� Bardzo często w programach Javy możnaspotkać instrukcję �� poprzedzającąpojedynczą, wciętą instrukcjęnie umieszczoną w nawiasachklamrowych. Taka poprawna składniaoznacza, że instrukcja warunkowa ��dotyczy tylko jednej, następującej po niejinstrukcji. Dla zachowania przejrzystościkodu, w książce tej zawsze będziemynastępujące po �� instrukcje umieszczaćw nawiasach klamrowych.
4. ������������������������ �.��"���� �������"�
Teraz wstawiamy dwie nowe instrukcjemetodzie ���� ". Pierwsza określa, żechcemy użyć interfejsu �������������(omówionego w kroku 2.), by przechwytywaćdziałania użytkownika w polu tekstowym�������. Dzięki temu, za każdym razem,kiedy użytkownika cokolwiek wpiszew tym polu, wyzwolone będzieodpowiednie zdarzenie w Javie (ang. event).
Druga linia spowoduje wyświetlenie polatekstowego w obszarze apletu.
5. �� ������,��-��/�##"�+�����*����+ #0����1�23#4�������,��-��%!5%65"�7
Wtedy, i tylko wtedy, gdy łańcuch������,��-�� zawiera jakikolwiek znak(długość łańcucha jest większa od zera),wyświetlamy tekst wpisany przezużytkownika. Jeśli łańcuch jest pusty,instrukcja +�����*����+ " nie zostaniewykonana.
6. ������ �������8�������� �����9 ����"�������,��-�����������+������ "�������� "�7
Ponieważ dodaliśmy wcześniej������������� do pola tekstowego�������, metoda �����8������� "będzie obsługiwać wszystkie zdarzeniawywołane przez użytkownika. Jedynymmożliwym zdarzeniem w tym aplecie jestwpisanie tekstu w jedynym polu tekstowym.Kiedy to się stanie, przypisujemy zmiennejłańcuchowej ������,��-�� dane z tego pola.Następnie wywołujemy metodę ������� ",która odświeża obszar apletu (efektmożemy zobaczyć na rysunku 6.1).
Instru
kcje
waru
nkow
e —
if
Rozdział 6.
88
Inst
rukcj
e w
aru
nkow
e —
if
Tabela 6.1. Zdarzenia w Javie
Interfejs Komponenty Metody
�������� ����� '-���� (przycisk) ������8��0����23
�� � (lista)
9�.�*��� (pole tekstowe)
:��-;��� (element menu)
��- ������� ����� <�������� (pasek przewijania) ��- �����=��-�"�����23
"��+������� ����� Wszystkie komponenty ���+�����>���23
"��+�����:�,�23
���+�����?� �@�23
���+�����<����23
"���������� ����� Wszystkie pojemniki ���+�������23
���+�����?���,�23
*��- �� ����� Wszystkie komponenty 0��- 7����23
0��- �� �23
;����� ����� "���5��. (pole wyboru) ����<����"�����23
"���5'�.:��-;��� (pole wyboru elementu menu)
"����� (lista rozwijana)
;���<��������� (element możliwy do wybrania)
�� � (lista)
A���� ����� Wszystkie komponenty 5��8�� �23
5��?���� �23
5��9�+�23
:�- ��� ����� Wszystkie komponenty ��- �"���5�23
��- �&�����23
��- �&.���23
��- �8�� �23
��- �?���� �23
:�- �:������� ����� Wszystkie komponenty ��- � �����23
��- �:�,�23
9�.��� ����� 9�.�"��+����� (komponent tekstowy) ��.�=��-�"�����23
B������ ����� B���� (okno) ���������,���23
�����"�� �23
�����"�� ���23
����� �����,���23
����� ������0��23
�����;����0��23
�����C+���23
Podejmowanie decyzji
89
Przechwytywanie błędów
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 aplet6.2 pokazują, jak przechwycić potencjalnebłędy, zanim spowodują poważne problemyw działaniu apletu.
Aby przechwycić błędy, należy użyć:
1. ������������:+��,������������������� ;"������������8����<��
Powyżej definiujemy zmienną���:+��,����� typu ��������� (poletekstowe o długości 5). Wykorzystamyto pole do pobierania od użytkownikazgadywanej liczby. Zmienna ��������8���posłuży nam do przechowywania wpisywanejprzez użytkownika liczby — przypisujemyjej wartość początkową <�. Wartość jest napewno niepoprawna (szukana liczba należydo przedziału od 1 do 100), zatem używamy<�, by program „wiedział”, że użytkowniknie podał jeszcze żadnej wartości.
2. ����=�-������=��� ���" �� �����+��>��.������ "��55"4��
Metoda Javy �� �����+�>��.������ "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ęc72,2 lub 11,1). Na końcu przekształcamytę wartość na liczbę całkowitą (rzutujemyna typ ���), co powoduje obcięcie częścidziesiętnej naszej liczby (otrzymujemyzatem liczbę od 0 do 99). Po dodaniu 1mamy wynik od 1 do 100 i przypisujemytaką właśnie wartość zmiennej �=�-������=��.Zarówno zmienna ��������8���,jak i �=�-������=�� są typu ���.
Prze
chw
yty
wanie
błę
dów
Listing HTML 6.2. Wywołuje aplet 6.2 i umieszcza
go w oknie przeglądarki internetowej
�������������������� ������D�������������������������������������������� ����� ���� !"�#$%$##&%�� �%�'(&!%$$�$)*#!! !(�������)$$����������$$�������+����++�����������,����+��������������,��-����++���D���� ���+������������+��,��-����++����������.%��,�%�++���/,�� ������(���+���������� ���+������,��-���0�� ����������+����++���������.%��,�%�++���/�,�� ������(�������++���D���� ��������)$$����������$$� ���+�������0�� ���+�-��� +��������+�����,�� -������+��-�� ��+�-������(�+�-���%�� ����������������������������������������
Rozdział 6.
90
3. *����+���������=�,���������8���4#������=�-��?���=�?#�+������� �"�
Wewnątrz metody ����� " zdefiniowaliśmynową zmienną łańcuchową: ���������=�,.Przypisujemy jej wartość zmiennej��������8��� z dołączonym komunikatemo udanej próbie odgadnięcia liczby(patrz rysunek 6.2). W drugiej instrukcjiustawiamy czcionkę dla naszego apletu(za pomocą zmiennej �).
4. �� ��������8���/��=�-������=��"����������=�,���������8���4#���������=�-��?���=�?#�7
Oto nasza pierwsza instrukcja ��.Sprawdzamy w niej, czy liczba będącawartością zmiennej ��������8��� różni sięod wylosowanej wcześniej wartości�=�-������=��; sprawdzamy zatem,czy podana przez użytkownika liczba różnisię od wartości, którą próbuje odgadnąć.Jeśli wynikiem porównania będzie ����(użytkownikowi nie udało się odgadnąćnaszej liczby), zostanie uruchomionykod znajdujący się wewnątrz nawiasówklamrowych. W przeciwnym wypadku,ten fragment programu zostanie pominięty.Jeśli użytkownik nie odgadł wylosowanejliczby, ponownie ustawiamy zmienną���������=�,, tym razem z komunikatemo nieudanej próbie (patrz rysunek 6.3).
Prz
ech
wyty
wanie
błę
dów
Aplet 6.2. Zagrajmy w grę „zgadnij, jaką sobie
wymyśliłem liczbę”
��+�����,������1/��+�����,���++�����++���/��+�����,�������,����1/
+-������� �++���D�.��� �++�����+������ ��������� �����4��� ���� ������ :+�,������� ��� ���� ���;!���������� ��7������<���������=�-����=��������!�����+�>�.����������!����55!�4����������"���� �������#��� �$���#%������&'�(%��� )!�
+-����,������234 ��'��5���-�2"����������3/+���E������������������ �����2��� 3/�2+���E��������3/6
+-����,��+����27��+��� �34����*����+���������=�,������ ��7����4�#������ ����=�-�?����=�?#�
����+�� ������"!������"����� ��7����/���=�-����=�!����������������=�,������ ��7����4�#��� �������� ����=�-�?����=�?#�����9�����"����� ��7����@��!����������������=�,���#'�+��������=�A����������������55#�����9����+����*����+���������=�,%� 5%�65!�6
������������������7 �"��� ��������8 ��� !�������"�� �+ �*���� �!������� �"�� ���� ��!����������,������������� ��7������B�� + ����� B��������������� :+�,����+ �� ���!!�������9���������.��C��� ������8�� �������!������������� ��7������<��������9������� �����!�666
Podejmowanie decyzji
91
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
5. �� ��������8���@�"����������=�,�#'�+��������=�A�����55#�7
Oto kolejna instrukcja warunkowa ��.Tym razem sprawdzamy, czy wartośćzmiennej ��������8��� jest mniejsza od 1,co oznacza, że podana wartość jest spozanaszego przedziału. W takim przypadkuprzypominamy użytkownikowi, jakiejliczby od niego oczekujemy (widać tona rysunku 6.4).
6. +�����*����+ ���������=�,%!5%65"�
Za pomocą tej instrukcji wyświetlamy to,co wcześniej przypisaliśmy wartości���������=�, (odpowiedni komunikato trafieniu, chybieniu, bądź o podaniuliczby spoza przedziału).
7. ������ �������8�������� �����9 ����"��� ��+��*���� "�������������������"�
Oto metoda �����8������� "wyzwalana zdarzeniem generowanymprzez użytkownika. Ten fragment kodujest uruchamiany za każdym razem,gdy użytkownik wpisuje cokolwiekw polu tekstowym. Na początku metody�����8������� " sprawdzamy,czy zdarzenie, które chcemy obsłużyć,rzeczywiście dotyczy pola tekstowego.Sprawdzamy zatem za pomocą instrukcjiwarunkowej ��, czy źródłem zdarzeniajest obiekt pola tekstowego (egzemplarzklasy ���������).
Prze
chw
yty
wanie
błę
dów
Rozdział 6.
92
8. ��,�
��������8����B���+��������B��� ���:+��,������+������ ""�7����. C����������9��������"���������8����<��7������� "�
Instrukcja ��, jest specyficznym rodzajeminstrukcji warunkowej. W tym przypadkupróbujemy wykonać instrukcję, która możespowodować błąd. Umieszczamy ją wewnątrzbloku ��,D����.. Jeśli jej działanie będziepoprawne (nie spowoduje błędu), nie będzieto miało znaczenia. W przeciwnym wypadkuspowoduje wyjątek, który należy przechwycići obsłużyć (za pomocą instrukcji ����.).W tym przypadku próbujemy przekształcićwpisany przez użytkownika tekst na liczbę.Ponieważ w polu tekstowym użytkownikmoże wpisać dowolny ciąg znaków, takieprzekształcenie może się nie udać i stądkonieczność użycia bloku ��,D����..Jeśli podany łańcuch ma poprawny formatliczbowy, przypisujemy wartość otrzymanejliczby zmiennej ��������8���.W przeciwnym razie jest wyzwalanywyjątek C����������9������� (błędnyformat liczby), wówczas przypisujemyzmiennej ��������8��� wartość <�.Niezależnie od rezultatu przekształceniawywołujemy metodę ������� ",która przerysuje obszar apletu.
Wskazówka
� Powyższy przykład nie prezentujenajlepszego pomysłu na tego typu grę.Średnio użytkownik musi 50 razyspróbować szczęścia, zanim odgadniewylosowaną liczbę. W następnymprzykładzie zaprezentujemy dużociekawsze rozwiązanie.
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 niechcianezdarzenia. Przykładowo, Java niebędzie w stanie zamienić liter na liczbę.
Kiedy Java wyzwala wyjątek, Ty,programista, musisz go przechwycić.Zrobisz to za pomocą słowakluczowego ����., po którym określisz,co program Javy ma zrobić w raziewystąpienia potencjalnych wyjątków.
Prz
ech
wyty
wanie
błę
dów
Podejmowanie decyzji
93
Więcej o instrukcjachwarunkowych — if…else
Niekiedy niezbędne jest jedynie wyrażenietego, co ma się stać, jeśli dane wyrażenie jestprawdziwe. Czasem jednak będziesz chciałwyznaczyć instrukcje, które powinny byćprzetworzone, gdy warunek instrukcji �� niejest spełniony. Służy do tego instrukcja ����wskazująca na blok kodu uruchamiany tylkowtedy, gdy warunek instrukcji warunkowej��nie jest spełniony. Listing HTML 6.3 i aplet6.3 prezentują poprawiony aplet gry „zgadnij,jaką sobie wymyśliłem liczbę”, który prezentujeużytkownikowi kierunek, w którym powinienpodążać.
Aby korzystać z konstrukcji if…else,należy zastosować:
1. �� ��������8���/��=�-������=��"�
Zaczynamy od sprawdzenia, czy podanaprzez użytkownika liczba różni się odwylosowanej. Fragment kodu poprzedzonytą instrukcją warunkową zostanie wykonanytylko w przypadku niezgodności liczbyużytkownika z wylosowaną przez aplet.
2. �� ��������8���@�"����������=�,�#'�+��������=�A�����55#�7
Teraz sprawdzamy, czy zmienna��������8��� ma wartość <�, cooznaczałoby, że metoda ����� " działapo raz pierwszy lub że użytkownikwpisał ciąg znaków, którego nie możnaprzekształcić na liczbę. Jeśli warunekjest spełniony, wyświetlamy komunikat„Odgadnij liczbę od 1 do 100”.
Wię
cej o
instru
kcja
ch w
aru
nkow
ych
Listing HTML 6.3. Wyświetla aplet 6.3 w oknie
przeglądarki internetowej
�������������������� ������(�������������������������������������������� ����� ���� !"�#$%$##&%�� �%�'(&!%$$�$)*#!! !(�������)$$����������$$�������+����++�����������,����+��������������,��-����++���(���� ���+������������+��,��-����++����������.%��,�%�++���/,�� ������(���+���������� ���+������,��-���0�� ����������+����++���������.%��,�%�++���/�,�� ������(�������++���(���� ��������)$$����������$$� ���+�������0�� ���+�-��� +��������+�����,�� -������+��-�� ��+�-������(�+�-���%�� ����������������������������������������
Rozdział 6.
94
3. �����
W przeciwnym wypadku, jeśli wartośćzmiennej ��������8��� jest różna odwartości zmiennej �=�-������=�� oraz��������8��� jest poprawną liczbą,uruchamiamy fragment kodu poprzedzonysłowem ����. W tym przypadku fragmentskłada się z kolejnego bloku ��D����.
4. �� ��������8���@�=�-������=��"����������=�,���������8���4#��=���1#�7��������������=�,���������8���4#��=���E#�7
Teraz sprawdzamy, czy wartość zmiennej��������8��� jest mniejsza od wartościprzechowywanej w zmiennej �=�-������=��.Jeśli tak, zmienna ��������8��� będziewyświetlona z komunikatem, że podanaliczba jest za mała. W przeciwnym raziezakomunikujemy użytkownikowi, że jestza duża. Na rysunku 6.5 prezentujemywygląd apletu, gdy podana liczba jestza duża, rysunki 6.6 i 6.7 prezentują efektdla zbyt małej liczby. Jeśli w końcu podamyliczbę równą szukanej, zobaczymykomunikat widoczny na rysunku 6.8.
Wię
cej o inst
rukcj
ach
waru
nkow
ych
Aplet 6.3. Ulepszona wersja gry „zgadnij, jaką
sobie wymyśliłem liczbę”
��+�����,������1/��+�����,���++�����++���/��+�����,�������,����1/
+-������� �++���(�.��� �++�����+������ ��������� �����49�.�*���+���E������������9�.�*���2)3/����� ��+��8�����%�/��� @-5������@���2���32��,�������:����������231�$$3F�/*���0����*���2�9��� ?�����G*����'C� G�D#3/
+-����,������234 ��'��5���-�2"����������3/+���E������������������ �����2��� 3/�2+���E��������3/6
+-����,��+����27��+��� �34<����� ���- ���@����� ��+��8����F���� � @-5��H���@�H�/
�� ��*���203/�����"����� ��7����/���=�-����=�!���������"����� ��7����@��!������������������=�,���#'�+��������=�A������������������55#�������9������ �� �����������"����� ��7����@��=�-����=�!��������������������=�,������ ��7����4�#��������������=��1�#���������9�������� �� ��������������������=�,������ ��7����4�#��������������=���D�#���������966�����<�����2 ���- ���@��GD$G�$3/6
+-����,��������8��0����2������&,����34�02�����<�-���23�� ������09�.�*���34���4�� ��+��8�����;�������+�� �;���2+���E������������9�.�233/6�����2I-����*�����&.��+����.34�� ��+��8�����%�/6��+����23/666
Podejmowanie decyzji
95
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ść
Wskazówka
� W poprzednim przypadku użytkownikmusiał próbować 50 razy, by osiągnąć 50%szans na sukces. W tym przypadku mamytaką samą możliwość odgadnięcia liczbypo najwyżej siedmiu próbach.
Wię
cej o
instru
kcja
ch w
aru
nkow
ych
Rozdział 6.
96
Powtarzanie czynnościza pomocą pętli
Struktura ��D����, którą posługiwaliśmy sięw poprzednim przykładzie, pozwalała uruchamiaćalbo jeden, albo drugi blok kodu. W przyszłościczęsto możesz stawać przed koniecznością wpisaniajednej lub wielu instrukcji, które powinny byćuruchomione wielokrotnie. Rozwiązaniem, którepozwala to zrealizować, jest pętla. Listing HTML6.4 i aplet 6.4 demonstrują jeden z rodzajów pętli:��. W poniższym przykładzie umożliwimyużytkownikowi wpisanie liczby, na podstawiektórej wyświetlimy rząd gwiazdek w oknieprzeglądarki.
Zapętlenie kodu
Pętla �� składa się z trzech części (patrzrysunek 6.10):
1. Inicjalizacja — podczas pierwszegoprzejścia pętli inicjalizowana jestzmienna pętli — licznik pętli.
2. Ograniczenie — tak określamy, kiedypętla się zakończy. W normalnychwarunkach ludzie odliczają od jednegodo dziesięciu; powszechną praktykąw językach programowania jestodliczanie od zera do dziewięciu.W obu przypadkach kod wewnątrzpętli zostanie przetworzony dziesięćrazy, jednak metoda liczenia odzera jest wygodniejsza w językachprogramowania takich jak Java z racjiindeksowania tablic od zera. Dlategowłaśnie określamy ograniczeniaw pętli jako „mniejszy niż wartość���=��F=,�-���-�”, a nie „mniejszylub równy wartości ���=��F=,�-���-�”.
3. Inkrementacja — w tej częściokreślamy, jak dalece zwiększaćlicznik pętli w każdej kolejnej iteracjipętli. W tym przypadku dodajemyjeden za pomocą znaków 44po identyfikatorze zmiennej.
Rysunek 6.10. Trzy części pętli
Rysunek 6.9. Użytkownik poprosił o 29 gwiazdek
i natychmiast je otrzymał
Pow
tarz
anie
czy
nnośc
i za
pom
ocą
pętl
i
Listing HTML 6.4. Oto, jak możemy wywołać nasz
nowy aplet
�������������������� ������#�������������������������������������������� ����� ���� !"�#$%$##&%�� �%�'(&!%$$�$)*#!! !(�������)$$����������$$�������+����++�����������,����+��������������,��-����++���#���� ���+������������+��,��-����++����������.%��,�%�++���/,�� ������(���+���������� ���+������,��-���0�� ����������+����++���������.%��,�%�++���/�,�� ������(�������++���#���� ��������)$$����������$$� ���+�������0�� ���+�-��� +��������+�����,�� -������+��-�� ��+�-������(�+�-���%�� ����������������������������������������
Podejmowanie decyzji
97
Aby korzystać z pętli for,należy zastosować:
1. �� ���=��F=,�-���-�@�GG����=��F=,�-���-�H;5"�������.0,�����,�#8������=�A����;5#�7
Na początku upewniamy się, czy użytkownikwpisał liczbę mieszczącą się w założonymprzedziale (od 1 do 50).
2. ������� ��5��@���=��F=,�-���-���44"�������.0,�����,�������.0,�����,�4#�#�77
Jeśli liczba jest prawidłowa (nie spełnionywarunek instrukcji �� z poprzedniego kroku),przechodzimy do pętli ��. Pierwsza częśćinicjalizuje licznik pętli � wartością 5.W drugiej części określamy, że pętla będziedziałać tak długo, aż � będzie mniejszeod wartości podanej przez użytkownika.Trzeci element określa operację wykonywanąprzy każdej iteracji pętli, w tym przypadkulicznik pętli będzie zwiększany o �.Na rysunku 6.9 widać efekt działaniaapletu po tym, jak użytkownik wpisał „29”.Do zmiennej ������.0,�����, (początkowojest pustym łańcuchem) dodajemy gwiazdkęprzy każdym nawrocie pętli.
Wskazówka
� Znaki GG pomiędzy warunkamisprawdzającymi, czy ���=��F=,�-���-�jest mniejsza od 1 i większa niż 50oznaczają logiczną alternatywę (czyli „lub”).Mówi to, że cały warunek �� jest prawdziwy,jeśli choć jeden z warunków składowych(rozdzielonych GG) jest prawdziwy.Gdybyśmy chcieli, by koniecznabyła prawdziwość oby warunków,rozdzielilibyśmy je znakami IIoznaczającymi koniunkcję (czyli „i”).
Pow
tarza
nie
czynności za
pom
ocą
pętli
Aplet 6.4. Aplet „pyta” użytkownika o liczbę
gwiazdek i wyświetla je za pomocą pętli
��+�����,������1/��+�����,���++�����++���/��+�����,�������,����1/
+-������� �++���#�.��� �++�����+������ ��������� �����49�.�*���+���J@��5����5�����9�.�*���2)3/������@��J@��5����5��%�/*���0����*���2�9��� ?�����G*����'C� G�D#3/
+-����,������234 ��'��5���-�2"����������3/+���J@��5����5����������� �����2��� 3/�2+���J@��5����5�3/6
+-����,��+����27��+��� �34<���������-��B�� ��������/����/
�� ��*���203/�����"�����=�E=,�-����-�@���FF��������=�E=,�-����-�G�;5!�������������.0,������,���#7�������=�A���������������;5#�����9���� �� ��������"������5���@���=�E=,�-����-���44!���������������.0,������,��������.0,������,�4���������#�#�������9����9�����<�����2����-��B�� �����GD$G�$3/6
+-����,��������8��0����2������&,����34�02�����<�-���23�� ������09�.�*���34���4���@��J@��5����5��;�������+�� �;���2+���J@��5����5�����9�.�233/6�����2I-����*�����&.��+����.34���@��J@��5����5��%�/6��+����23/666
Rozdział 6.
98
Inny rodzaj pętli — while
W Javie istnieją trzy sposoby budowania pętli.Pierwszym jest pętla omówiona w poprzednimprzykładzie — pętla ��, dwie pozostałeto odmiany pętli �.���. Kod zawarty w pętli�.��� działa tak długo, jak długo spełnionyjest warunek tej pętli (patrz listing HTML 6.5i aplet 6.5). Przy pierwszym sprawdzeniu tegowarunku, które wykaże jego nieprawdziwość,działanie pętli jest kończone. Jeśli już przypierwszym sprawdzeniu, warunek okaże sięnieprawdziwy, pętla w ogóle nie zostanieuruchomiona.
Rysunek 6.11. Teraz użytkownik poprosił jedynie
o trzy gwiazdki
Inny r
odza
j pętl
i —
while
Listing HTML 6.5. Wstawia aplet 6.5 na stronę WWW
�������������������� ������)�������������������������������������������� ����� ���� !"�#$%$##&%�� �%�'(&!%$$�$)*#!! !(�������)$$����������$$�������+����++�����������,����+��������������,��-����++���)���� ���+������������+��,��-����++����������.%��,�%�++���/,�� ������(���+���������� ���+������,��-���0�� ����������+����++���������.%��,�%�++���/�,�� ������(�������++���)���� ��������)$$����������$$� ���+�������0�� ���+�-��� +��������+�����,�� -������+��-�� ��+�-������(�+�-���%�� ����������������������������������������
Podejmowanie decyzji
99
Aby używać pętli while, należy wpisać:
1. �.��� �@���=��F=,�-���-�"������.0,�����,�������.0,�����,4�#�#��44�7
Wartość zmiennej ���=��F=,�-���-�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ż � jest inicjalizowanewartością 5, powyższa pętla w ogólenie zadziała, jeśli nie podano prawidłowejwartości, ponieważ <� nie jest większe od 5.Jeśli podana przez użytkownika wartośćjest prawidłowa, kod zawarty w pętli zostanieprzetworzony tyle razy, ile przypisanozmiennej ���=��F=,�-���-�. Za każdymrazem zmienna � jest zwiększana o 1.Przykładowo, jeśli wartość zmiennej���=��F=,�-���-� wynosi !;, pętlauruchomi się 25 razy. Jeśli ���=��F=,�-���-�wynosi <�, pętla �.��� przed pierwszymuruchomieniem stwierdzi nieprawdziwośćwarunku �@���=��F=,�-���-�i nie uruchomi się ani razu.
Wskazówka
� Upewnij się, że pętla �.��� kiedyś sięzakończy. Gdybyś, przykładowo, pominąłinstrukcję �44 w powyższym przykładzie,stworzył byś nieskończoną pętlę, czyli taką,która sama nigdy się nie zakończy.
Inny ro
dza
j pętli —
while
Aplet 6.5. Ciekawe, ile gwiazdek użytkownik będzie
chciał wyświetlić tym razem
��+�����,������1/��+�����,���++�����++���/��+�����,�������,����1/
+-������� �++���)�.��� �++������+������ �������� �����49�.�*���+���J@��5����5�����9�.�*���2)3/������@��J@��5����5��%�/*���0����*���2�9��� ?�����G*����'C� G�D#3/
+-����,������234 ��'��5���-�2"����������3/+���J@��5����5����������� �����2��� 3/�2+���J@��5����5�3/6
+-����,��+����27��+��� �34<���������-��B�� ��������/�����$/
�� ��*���203/�02���@��J@��5����5��)$34���@��J@��5����5��%�/6�02���@��J@��5����5���34����-��B�� �������8������@�K����)$�/6�����.�� ����@����=�E=,�-����-!�������������.0,������,��������.0,������,�4�#�#��������44�����9�����<�����2����-��B�� �����GD$G�$3/6
+-����,��������8��0����2������&,����34�02�����<�-���23�� ������09�.�*���34���4���@��J@��5����5��;�������+�� �;���2+���J@��5����5�����9�.�233/6�����2I-����*�����&.��+����.34���@��J@��5����5��%�/6��+����23/666
Rozdział 6.
100
Ostatni rodzaj pętli— do…while
Trzecim i ostatnim typem pętli w Javie jest�D�.���. W układzie �D�.��� sprawdzamywarunek pętli na końcu pętli, a nie na początku.Oznacza to, że pętla zawsze się uruchomiprzynajmniej raz. Listing HTML 6.6 i aplet 6.6prezentują zastosowanie pętli �D�.���.
Aby użyć pętli do…while,należy wpisać:
1. ��������.0,�����,�������.0,�����,4�#�#��44�7�.��� �@���=��F=,�-���-�"�
W takim układzie zmienna łańcuchowa������.0,�����, będzie zawsze zawierałaprzynajmniej jedną gwiazdkę. Musimywięc uważać, w jaki sposób umieścimyten fragment w naszym programie— w tym przypadku sprawdzamy przedwejściem do pętli, czy wartość zmiennej���=��F=,�-���-� jest poprawna(od 1 do 50).
Pętla będzie działać tak długo, jak długo�będzie mniejsze od ���=��F=,�-���-�.Efekt widać na rysunku 6.12.
Rysunek 6.12. Użytkownik zażądał 34 gwiazdki
Ost
atn
i ro
dza
j pętl
i —
do…
while
Listing HTML 6.6. Poniższy plik HTML wywołuje
aplet 6.6 zawierający pętlę do…while
�������������������� ��������������������������������������������������� ����� ���� !"�#$%$##&%�� �%�'(&!%$$�$)*#!! !(�������)$$����������$$�������+����++�����������,����+��������������,��-����++�������� ���+������������+��,��-����++����������.%��,�%�++���/,�� ������(���+���������� ���+������,��-���0�� ����������+����++���������.%��,�%�++���/�,�� ������(�������++�������� ��������)$$����������$$� ���+�������0�� ���+�-��� +��������+�����,�� -������+��-�� ��+�-������(�+�-���%�� ����������������������������������������
Podejmowanie decyzji
101
Osta
tni ro
dza
j pętli —
do…
while
Aplet 6.6. Za pomocą pętli do…while przetwarzamy
żądanie użytkownika
��+�����,������1/��+�����,���++�����++���/��+�����,�������,����1/
+-������� �++�����.��� �++�����+������ ��������� �����49�.�*���+���J@��5����5�����9�.�*���2)3/������@��J@��5����5��%�/*���0����*���2�9��� ?�����G*����'C� G�D#3/
+-����,������234 ��'��5���-�2"����������3/+���J@��5����5����������� �����2��� 3/�2+���J@��5����5�3/6
+-����,��+����27��+��� �34<���������-��B�� ��������/�����$/
�� ��*���203/�02���@��J@��5����5���LL����@��J@��5����5��)$34����-��B�� �������8������@�K����)$�/6�� �4�����������������������.0,������,��������.0,������,�4���������#�#����������44�������9��.�� ����@����=�E=,�-����-!�6�����<�����2����-��B�� �����GD$G�$3/6
+-����,��������8��0����2������&,����34�02�����<�-���23�� ������09�.�*���34���4���@��J@��5����5��;�������+�� �;���2+���J@��5����5�����9�.�233/6�����2I-����*�����&.��+����.34���@��J@��5����5��%�/6��+����23/666
Rozdział 6.
102
Przerywanie działania pętli
Istnieje możliwość opuszczenia pętliprzetwarzanej zgodnie z jej warunkami.Taki sposób kończenia pętli można uzyskaćza pomocą instrukcji ����-.
W listingu HTML 6.7 i aplecie 6.7 użytkownikmoże wpisać dowolną liczbę. Niezależniejednak od jej wielkości, pętla nie zadziaławięcej niż dwadzieścia razy.
Aby przerwać działanie pętli,należy użyć:
1. �� ��5��@���=��F=,�-���-���44"��� �H�!5"����-�������.0,�����,�������.0,�����,4�#�#�7
To jest standardowa pętla ��, któraw najprostszej formie działałaby ażdo osiągnięcia przez licznik � wartościzmiennej ���=��F=,�-���-�. Wstawienieinstrukcji ����- wewnątrz pętli sprawi,że jej działanie zostanie przerwane,gdy �osiągnie wartość !5.
Instrukcja ����- powoduje skokdo pierwszej instrukcji znajdującej sięza pętlą — w naszym przypadku jest to+�����*����+ ������.0,�����,%!5%65".Efekt jest widoczny na rysunku 6.13.
Rysunek 6.13. Niezależnie od tego, jaką liczbę
podamy, zobaczymy maksymalnie 20 gwiazdek
Prz
ery
wanie
dzi
ała
nia
pętl
i
Listing HTML 6.7. Wstawia na stronę aplet 6.7
�������������������� ������M�������������������������������������������� ����� ���� !"�#$%$##&%�� �%�'(&!%$$�$)*#!! !(�������)$$����������$$�������+����++�����������,����+��������������,��-����++���M���� ���+������������+��,��-����++����������.%��,�%�++���/,�� ������(���+���������� ���+������,��-���0�� ����������+����++���������.%��,�%�++���/�,�� ������(�������++���M���� ��������)$$����������$$� ���+�������0�� ���+�-��� +��������+�����,�� -������+��-�� ��+�-������(�+�-���%�� ����������������������������������������
Podejmowanie decyzji
103
Wskazówka
� W Javie istnieje także instrukcja �������.Kiedy jej użyjemy, następujący po niejfragment kodu wewnątrz pętli zostaniepominięty, nie przerywamy jednak jejdziałania. W powyższym przypadku,gdybyśmy zastąpili instrukcję ����-instrukcją �������, pomijane byłybyinstrukcje dopisywania gwiazdki dozmiennej ������.0,�����, od momentuosiągnięcia przez � wartości !5.W przeciwieństwie jednak do przerwaniadziałania pętli instrukcją ����-, gdybyśmyużyli �������, pętla działałaby nadal,aż do momentu zrównania się licznika �z wartością zmiennej ���=��F=,�-���-�.
Prze
ryw
anie
dzia
łania
pętli
Aplet 6.7. Demonstruje opuszczenie pętli za pomocą
instrukcji break
��+�����,������1/��+�����,���++�����++���/��+�����,�������,����1/
+-������� �++���M�.��� �++�����+������ ��������� �����49�.�*���+���J@��5����5�����9�.�*���2)3/������@��J@��5����5��%�/*���0����*���2�9��� ?�����G*����'C� G�D#3/
+-����,������234 ��'��5���-�2"����������3/+���J@��5����5����������� �����2��� 3/�2+���J@��5����5�3/6
+-����,��+����27��+��� �34<���������-��B�� ��������/����/
�� ��*���203/�02���@��J@��5����5���34����-��B�� �������8������@�K����D$�/6�� �4������"������5���@���=�E=,�-����-���44!�����������"����G�� 5!��� -��������������.0,������,��������.0,������,�4���������#�#�������96�����<�����2����-��B�� �����GD$G�$3/6
+-����,��������8��0����2������&,����34�02�����<�-���23�� ������09�.�*���34���4���@��J@��5����5��;�������+�� �;���2+���J@��5����5�����9�.�233/6�����2I-����*�����&.��+����.34���@��J@��5����5��%�/6��+����23/666
Rozdział 6.
104
Konstrukcja switch…case
Java oferuje jeszcze jeden sposób kontrolowaniaprzetwarzania kodu — konstrukcję �����.D����.Najprostszym sposobem zrozumienia istotytej instrukcji jest spojrzenie na nią jak na zbiórinstrukcji ��D����. Zamiast powiedzieć: „jeślidzisiaj jest poniedziałek, zrób to; w przeciwnymrazie, 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 �����.D����, by bezpośredniowyróż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życiemkonstrukcji �����.D����.
Aby użyć instrukcji switch…case,należy zastosować:
1. �����������������J������������������������B������������
Ponieważ w naszym nowym apleciedo interakcji z użytkownikiem posłużymy sięprzyciskami opcji zamiast polem tekstowym,musimy użyć zupełnie innych metoddo przechwytywania zdarzeń. Korzystamywięc z interfejsu B�����������, którydostarcza nam metodę ����*����K.��+�� "wyzwalaną przez zdarzenie kliknięciaprzycisku opcji.
2. K.��-��L�������K.��-���K.��-��-�����K.��-&�%�=,��K.��-&�%�������K.��-&��
Każdy przycisk opcji K.��-�� jestpoczątkowo definiowany jako pole wyboru.Później, w kroku 4., określimy, że wszystkietrzy pola będą przyciskami opcji należącymido jednej grupy K.��-��L���.
3. ����K.��-������K.��-��L��� "�
Tworzymy obiekt klasy K.��-��L���(grupa pól wyboru) nazwany ����K.��-��.
Konst
rukcj
a s
wit
ch…
case
Listing HTML 6.8. Tak wstawiamy naszą grę
zapisaną w aplecie 6.8
�������������������� ��������������������������������������������������� ����� ���� !"�#$%$##&%�� �%�'(&!%$$�$)*#!! !(�������)$$����������$$�������+����++�����������,����+��������������,��-����++�������� ���+������������+��,��-����++����������.%��,�%�++���/,�� ������(���+���������� ���+������,��-���0�� ����������+����++���������.%��,�%�++���/�,�� ������(�������++�������� ��������)$$����������$$� ���+�������0�� ���+�-��� +��������+�����,�� -������+��-�� ��+�-������(�+�-���%�� ���������������������������������
ch…
case
Podejmowanie decyzji
105
4. -�����K.��-&�����K.��-�� #M����N#%�����K.��-��%�����"�-�����K.��-&�����B����������� �.��"����� -�����K.��-&�"�
Te trzy instrukcje tworzą przycisk opcji-�����K.��-&� będący częścią grupy����K.��-��. Klikając którykolwiekprzycisk należący do tej grupy, spowodujesz,że wszystkie pozostałe przyciski z tej grupyzostaną wyłączone. Pierwszym parametremmetody K.��-�� " jest etykieta (nazwaprzycisku wypisana na ekranie), drugimparametrem jest wspomniana grupaprzycisków, jako trzeci parametr podajemystan przycisku (���� lub �����, zależnieod tego, czy chcemy, by był na początkuwłączony czy wyłączony). Następnieustawiamy ���B����������� �.��"dla nowego przycisku opcji, co pozwolinam dalej przechwytywać zdarzeniazwiązane z przyciskiem za pomocą metody����*����K.��+�� ". Kończymy ten fragmentkodu, wstawiając nasz przycisk opcjiw obszarze apletu.
5. �����. ���=��������"������3�,���������#M����N#�����-�����!3�,���������#CE,��#�����-�����O3�,���������#8�����#�����-��������3�,���������#&1?�#�7
Podobnie jak we wcześniejszychprzykładach, użyliśmy generatora liczblosowych Javy do przypadkowego wybraniakamienia, nożyc lub papieru przez naszaplet. W efekcie zmienna ���=��������zawiera liczbę losową od 1 do 3. Terazinstrukcja �����. " wybiera odpowiedniblok kodu ���� w zależności od wartościzmiennej ���=��������. Powyższy fragmentmoglibyśmy zapisać następująco:
Aplet 6.8. Zobaczmy, czy możemy wygrać
z naszym apletem
��+�����,������1/��+�����,���++�����++���/��+�����,�������,����1/
���������������� �H� �� �������� ������ � ����B� ����� � ���������@���+���-�2���32��,�������:����������231(3F�/*���0����*���2�9��� ?�����G*����'C� G���3/��I. �-���J������� �I. �-������I. �-����-�� �I. �-&��%���=,� I. �-&��%������ �I. �-&����������+���� @�8�������-�/<����������J@��5����5�/
+-����,������234 ��'��5���-�2"����������3/
������ �I. �-������� ��I. �-���J�����!�����-�� �I. �-&������ ��I. �-����#K�� L#%������� �I. �-���%�"�� !�5�����"���5'�.��;����� �����2��� 3/�25�����"���5'�.3/
��@���"���5'�.����"���5��.2�I�N����G�- ��"���5��.G0�� �3/��@���"���5'�.��;����� �����2��� 3/�2��@���"���5'�.3/
+�+���"���5'�.����"���5��.2�8�+����G�- ��"���5��.G0�� �3/+�+���"���5'�.��;����� �����2��� 3/�2+�+���"���5'�.3/6
+-����,��+����27��+��� �34������@��J@��5����5�/<�����������+���-/
�� ��*���203/
�02+���� @�8����34�����<�����2�E�����@���H�5����OG���N����+�+���P�GD$G�$3/+���� @�8�����0�� �/6�� �4�����������.����=���� ��!������������ ��3�����������,������ �����#K�� L#������������� -����������� � 3�����������,������ �����#C�D,� #������������� -�
�����
Konstru
kcja
switch
case
Rozdział 6.
106
�� ���=�����������"��,���������#M����N#�7������ ���=����������!"��,���������#CE,��#�7���������
I tak dalej, dla każdej możliwej wartości.
6. �����. �,��F=,�-���-���.���� 5""�����PMP3���=��F=,�-���-��������-�����PCP3���=��F=,�-���-��!�����-�����P8P3���=��F=,�-���-��O�����-��������3���=��F=,�-���-��5�7
W tym fragmencie kodu sprawdzamyzmienną typu �.�� (podobny typdo łańcucha, tyle że przechowujący tylkojeden znak), a nie, jak poprzednio, liczbę.Użytkownik dokonuje wyboru, klikającprzycisk opcji, co wyzwala zdarzenie Javy.Możemy odczytać etykietę klikniętegoprzycisku i przypisać zmiennejcałkowitoliczbowej ���=��F=,�-���-�odpowiednią wartość w celu późniejszegoporównania z wyborem apletu (zmienna���=��������). Rysunek 6.14 prezentujewidok apletu na początku gry. Rysunki 6.15,6.16 i 6.17 prezentują możliwe wyniki.
7. ������ ������*����K.��+�� B���9 ����"��� ��+��*���� "���������K.��-��"��,��F=,�-���-������K.��-����+��*�������K.��-�� "�+������� "�
Oto fragment kodu wyzwalany kliknięciemmyszą przez użytkownika. Jeśli obiekteminterakcji był przycisk opcji, zmiennej�,��F=,�-���-� przypisujemy etykietętego przycisku.
Konst
rukcj
a s
wit
ch…
case
Aplet 6.8. Zobaczmy, czy możemy wygrać z naszym
apletem — ciąg dalszy
�� �M3�����������,������ �����#7�� �#������������� -���������� "���3�����������,������ �����#&1?�#�������9
�����������.���,���E=,�-����-��.����5!!������������ �NKN3�������������=�E=,�-����-����������������� -����������� �NCN3�������������=�E=,�-����-��� ������������� -����������� �N7N3�������������=�E=,�-����-���M������������� -���������� "���3�������������=�E=,�-����-���5�������9
�02���@���+���-�����@��J@��5����5�34�����<�����2�?&:;<%@��������� @�@����@��GD$G�$3/6�� �4�022���@��J@��5����5����QQ����@���+���-��(3LL�2���@��J@��5����5���DQQ����@���+���-���3LL�2���@��J@��5����5���(QQ����@���+���-��D334�����<�����2�B����R��PB����R����F������+���-F���GD$G�$3/6�� �4�����<�����2�B����R�SPB����R����F������+���-F���GD$G�$3/66�����<�����2����@����T+�������G��S���N�K ����K��GD$G�$3/66
��������������� �*�� I.�+ ��B� �8 ��� !�������"�� �+ �*���� �!������� �"�I. �-���!���������,���E=,�-����-����� �I. �-�����������+ �* � �� �I. �-����!�+ ��� ��!���+����23/666
Podejmowanie decyzji
107
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
Wskazówki
� Instrukcja �����.D���� może być używanajedynie dla czterech typów prymitywów:�,��, �.��, ��� i �.��. Właśnie dlategow szóstym kroku sprawdzamy jedyniepierwszą literę zmiennej łańcuchowej�,��F=,�-���-� zamiast całego łańcucha.
� Gdybyśmy pominęli którąkolwiekinstrukcję ����- w powyższych blokach����, przetwarzane byłyby także następnebloki ����. Przerywanie wykonaniainstrukcji �����.D���� jest bardzoprzydatne, może jednak być źródłemwielu błędów w oprogramowaniu.Pamiętaj więc o wstawianiu instrukcji����- na końcu każdego bloku ����.
� Jeśli żadna z wartości wymienionychw instrukcjach ���� nie pasuje do wzorca,przetwarzany jest blok domyślny(rozpoczynający się od słowa �������).Nawet kiedy jesteś przekonany o tym,że któraś z opcji musi zostać wybrana,dla pewności używaj bloku �������.
Konstru
kcja
switch
…ca
se