• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Java. Podstawy. Wydanie VIII
 

Java. Podstawy. Wydanie VIII

on

  • 1,165 views

Zacznij tworzyć niezależne od platformy aplikacje jeszcze dziś!...

Zacznij tworzyć niezależne od platformy aplikacje jeszcze dziś!


* Jakie nowości kryją się w Java Standard Edition 6?
* Jak rozpocząć przygodę z językiem Java?
* Jak wykorzystać wielowątkowość?


Język programowania Java został stworzony i jest rozwijany przez firmę Sun Microsystems. Możliwość zastosowania go na różnych platformach została doceniona przez wielu programistów na świecie. Jednak nie jest to jedyna mocna strona Javy. Warto tu wskazać również jej silne ukierunkowanie na obiektowość, obsługę programowania rozproszonego, mechanizm automatycznego oczyszczania pamięci (ang. garbage collection). Dzięki swoim atutom, dobrej dokumentacji i licznych publikacjom Java jest dziś wiodącym rozwiązaniem na rynku języków programowania.
Książka "Java. Podstawy. Wydanie VIII" została zaktualizowana o wszystkie te elementy, które pojawiły się w wersji szóstej platformy Java Standard Edition. Tom pierwszy — "Podstawy" — zawiera wprowadzenie do języka programowania Java. Autorzy książki przedstawią tu założenia przyjęte przez firmę Sun przy tworzeniu tej platformy. Dowiesz się, jakie prawa rządzą programowaniem obiektowym oraz jak wykorzystać interfejsy i obsługę wyjątków. Dodatkowo będziesz mieć możliwość zapoznania się z elementami projektowania i tworzenia interfejsu użytkownika. W ostatnim rozdziale autorzy omówią wielowątkowość oraz sposób zastosowania tego typu rozwiązań w codziennej pracy programisty języka Java.


* Podstawy języka Java
* Programowanie obiektowe
* Interfejsy
* Sposób użycia klas proxy oraz klas wewnętrznych
* Projektowanie interfejsu użytkownika z wykorzystaniem biblioteki Swing
* Obsługa wyjątków
* Wykrywanie i rozwiązywanie problemów w kodzie
* Wielowątkowość


Wykorzystaj siłę obiektów. Programowanie obiektowe w języku Java ma przyszłość!

Statistics

Views

Total Views
1,165
Views on SlideShare
1,165
Embed Views
0

Actions

Likes
0
Downloads
1
Comments
0

0 Embeds 0

No embeds

Accessibility

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Java. Podstawy. Wydanie VIII Java. Podstawy. Wydanie VIII Document Transcript

    • Java. Podstawy. Wydanie VIII Autor: Cay S. Horstmann, Gary Cornell T³umaczenie: £ukasz Piwko ISBN: 978-83-246-1478-3 Tytu³ orygina³u: Core Java(TM), Volume I--Fundamentals (8th Edition) Format: 172x245, stron: 888 Zacznij tworzyæ niezale¿ne od platformy aplikacje jeszcze dziœ! • Jakie nowoœci kryj¹ siê w Java Standard Edition 6? • Jak rozpocz¹æ przygodê z jêzykiem Java? • Jak wykorzystaæ wielow¹tkowoœæ? Jêzyk programowania Java zosta³ stworzony i jest rozwijany przez firmê Sun Microsystems. Mo¿liwoœæ zastosowania go na ró¿nych platformach zosta³a doceniona przez wielu programistów na œwiecie. Jednak nie jest to jedyna mocna strona Javy. Warto tu wskazaæ równie¿ jej silne ukierunkowanie na obiektowoœæ, obs³ugê programowania rozproszonego, mechanizm automatycznego oczyszczania pamiêci (ang. garbage collection). Dziêki swoim atutom, dobrej dokumentacji i licznych publikacjom Java jest dziœ wiod¹cym rozwi¹zaniem na rynku jêzyków programowania. Ksi¹¿ka „Java. Podstawy. Wydanie VIII” zosta³a zaktualizowana o wszystkie te elementy, które pojawi³y siê w wersji szóstej platformy Java Standard Edition. Tom pierwszy — „Podstawy” — zawiera wprowadzenie do jêzyka programowania Java. Autorzy ksi¹¿ki przedstawi¹ tu za³o¿enia przyjête przez firmê Sun przy tworzeniu tej platformy. Dowiesz siê, jakie prawa rz¹dz¹ programowaniem obiektowym oraz jak wykorzystaæ interfejsy i obs³ugê wyj¹tków. Dodatkowo bêdziesz mieæ mo¿liwoœæ zapoznania siê z elementami projektowania i tworzenia interfejsu u¿ytkownika. W ostatnim rozdziale autorzy omówi¹ wielow¹tkowoœæ oraz sposób zastosowania tego typu rozwi¹zañ w codziennej pracy programisty jêzyka Java. • Podstawy jêzyka Java — Programowanie obiektowe — Interfejsy — Sposób u¿ycia klas proxy oraz klas wewnêtrznych — Projektowanie interfejsu u¿ytkownika z wykorzystaniem biblioteki Swing — Obs³uga wyj¹tków — Wykrywanie i rozwi¹zywanie problemów Wydawnictwo Helion w kodzie — Wielow¹tkowoœæ ul. Koœciuszki 1c Wykorzystaj si³ê obiektów. 44-100 Gliwice tel. 032 230 98 63 Programowanie obiektowe w jêzyku Java ma przysz³oœæ! e-mail: helion@helion.pl
    • Spis treÊci PodziÂkowania .........................................................................................................................................13 WstÂp ........................................................................................................................................................15 RozdziaÄ 1. WstÂp do Javy ........................................................................................................................21 Java jako platforma programistyczna .............................................................................. 21 Säowa klucze biaäej ksiögi Javy ...................................................................................... 22 Prosty .................................................................................................................... 23 Zorientowany obiektowo .......................................................................................... 23 Sieciowy ................................................................................................................. 24 Niezawodny ............................................................................................................ 24 Bezpieczny ............................................................................................................. 25 Niezale ny od architektury ....................................................................................... 26 Przeno ny .............................................................................................................. 26 Interpretowany ........................................................................................................ 27 Wysokowydajny ....................................................................................................... 27 Wielowñtkowy ......................................................................................................... 27 Dynamiczny ............................................................................................................ 28 Aplety Javy i internet ..................................................................................................... 28 Krótka historia Javy ...................................................................................................... 30 Gäówne nieporozumienia dotyczñce Javy ......................................................................... 32 RozdziaÄ 2. Érodowisko programistyczne Javy ................................................................................... 37 Instalacja oprogramowania Java Development Kit ........................................................... 38 Pobieranie pakietu JDK ........................................................................................... 38 Ustawianie cie ki dostöpu ...................................................................................... 40 Instalacja bibliotek i dokumentacji ............................................................................ 41 Instalacja przykäadowych programów ......................................................................... 42 Drzewo katalogów Javy ............................................................................................ 43 Wybór rodowiska programistycznego ............................................................................ 44 U ywanie narzödzi wiersza poleceþ ................................................................................ 44 Rozwiñzywanie problemów ....................................................................................... 46
    • 4 Java. Podstawy Praca w zintegrowanym rodowisku programistycznym .................................................... 47 Znajdowanie bäödów kompilacji ................................................................................ 50 Uruchamianie aplikacji graficznej ................................................................................... 51 Tworzenie i uruchamianie apletów ................................................................................. 53 RozdziaÄ 3. Podstawowe elementy jÂzyka Java .................................................................................... 59 Prosty program w Javie ................................................................................................. 60 Komentarze ................................................................................................................. 63 Typy danych ................................................................................................................. 64 Typy caäkowite ........................................................................................................ 64 Typy zmiennoprzecinkowe ........................................................................................ 65 Typ char ................................................................................................................. 66 Typ boolean ............................................................................................................ 68 Zmienne ...................................................................................................................... 69 Inicjacja zmiennych ................................................................................................. 70 Staäe ...................................................................................................................... 70 Operatory .................................................................................................................... 71 Operatory inkrementacji i dekrementacji ................................................................... 72 Operatory relacyjne i logiczne ................................................................................... 73 Operatory bitowe ..................................................................................................... 74 Funkcje i staäe matematyczne .................................................................................. 75 Konwersja typów numerycznych ................................................................................ 76 Rzutowanie ............................................................................................................. 77 Nawiasy i priorytety operatorów ................................................................................ 78 Typ wyliczeniowy ..................................................................................................... 79 ãaþcuchy ..................................................................................................................... 79 Podäaþcuchy ........................................................................................................... 79 Konkatenacja ......................................................................................................... 80 ãaþcuchów nie mo na modyfikowaè .......................................................................... 80 Porównywanie äaþcuchów ......................................................................................... 82 Wspóärzödne kodowe znaków i jednostki kodowe ....................................................... 83 API String ............................................................................................................... 84 Dokumentacja API w internecie ................................................................................ 86 Skäadanie äaþcuchów ............................................................................................... 87 Wej cie i wyj cie .......................................................................................................... 90 Odbieranie danych wej ciowych ................................................................................ 90 Formatowanie danych wyj ciowych ........................................................................... 93 Zapis do pliku i odczyt ............................................................................................. 97 Przepäyw sterowania ..................................................................................................... 99 Zasiög blokowy ....................................................................................................... 99 Instrukcje warunkowe ............................................................................................ 100 Pötle .................................................................................................................... 102 Pötle o okre lonej liczbie powtórzeþ ....................................................................... 107 Wybór wielokierunkowy — instrukcja switch ............................................................ 110 Instrukcje przerywajñce przepäyw sterowania ........................................................... 112 Wielkie liczby ............................................................................................................. 115 Tablice ...................................................................................................................... 118 Pötla typu for each ................................................................................................ 119 Inicjowanie tablic i tworzenie tablic anonimowych .................................................... 120 Kopiowanie tablicy ................................................................................................ 120 Parametry wiersza poleceþ .................................................................................... 122
    • Spis treÊci 5 Sortowanie tablicy ................................................................................................. 123 Tablice wielowymiarowe ......................................................................................... 127 Tablice postrzöpione ............................................................................................. 130 RozdziaÄ 4. Obiekty i klasy .....................................................................................................................133 Wstöp do programowania zorientowanego obiektowo .................................................... 134 Klasy ................................................................................................................... 134 Obiekty ................................................................................................................ 136 Identyfikacja klas .................................................................................................. 136 Relacje miödzy klasami ......................................................................................... 137 U ywanie klas predefiniowanych .................................................................................. 139 Obiekty i zmienne obiektów .................................................................................... 139 Klasa GregorianCalendar ....................................................................................... 142 Metody udostöpniajñce i zmieniajñce warto è elementu ........................................... 144 Definiowanie wäasnych klas ......................................................................................... 150 Klasa Employee .................................................................................................... 151 Stosowanie kilku plików ródäowych ........................................................................ 154 Analiza klasy Employee ......................................................................................... 154 Pierwsze kroki w tworzeniu konstruktorów ............................................................... 155 Parametry jawne i niejawne .................................................................................... 156 Korzy ci z hermetyzacji .......................................................................................... 157 Przywileje klasowe ................................................................................................ 159 Metody prywatne ................................................................................................... 160 Staäe jako pola klasy ............................................................................................. 161 Pola i metody statyczne .............................................................................................. 161 Pola statyczne ...................................................................................................... 161 Staäe statyczne ..................................................................................................... 162 Metody statyczne .................................................................................................. 163 Metody fabrykujñce ............................................................................................... 164 Metoda main ........................................................................................................ 165 Parametry metod ........................................................................................................ 167 Konstruowanie obiektów ............................................................................................. 173 Przeciñ anie ......................................................................................................... 173 Inicjacja pól warto ciami domy lnymi ...................................................................... 174 Konstruktor domy lny ............................................................................................ 175 Jawna inicjacja pól ................................................................................................ 175 Nazywanie parametrów .......................................................................................... 176 Wywoäywanie innego konstruktora .......................................................................... 177 Bloki inicjujñce ...................................................................................................... 178 Niszczenie obiektów i metoda finalize ..................................................................... 182 Pakiety ...................................................................................................................... 182 Importowanie klas ................................................................................................. 183 Importy statyczne .................................................................................................. 185 Dodawanie klasy do pakietu .................................................................................. 185 Zasiög pakietów .................................................................................................... 188 cie ka klas .............................................................................................................. 190 Ustawianie cie ki klas ......................................................................................... 192 Komentarze dokumentacyjne ...................................................................................... 193 Wstawianie komentarzy ......................................................................................... 193 Komentarze do klas .............................................................................................. 194 Komentarze do metod ........................................................................................... 194
    • 6 Java. Podstawy Komentarze do pól ................................................................................................ 195 Komentarze ogólne ............................................................................................... 195 Komentarze do pakietów i ogólne ........................................................................... 197 Generowanie dokumentacji .................................................................................... 197 Porady dotyczñce projektowania klas ........................................................................... 198 RozdziaÄ 5. Dziedziczenie .......................................................................................................................201 Klasy, nadklasy i podklasy .......................................................................................... 202 Hierarchia dziedziczenia ........................................................................................ 208 Polimorfizm .......................................................................................................... 208 Wiñzanie dynamiczne ............................................................................................ 210 Wyäñczanie dziedziczenia — klasy i metody finalne .................................................. 213 Rzutowanie ........................................................................................................... 214 Klasy abstrakcyjne ................................................................................................ 216 Dostöp chroniony .................................................................................................. 221 Klasa bazowa Object .................................................................................................. 222 Metoda equals ..................................................................................................... 223 Porównywanie a dziedziczenie ................................................................................ 224 Metoda hashCode ................................................................................................. 227 Metoda toString .................................................................................................... 229 Generyczne listy tablicowe .......................................................................................... 234 Dostöp do elementów listy tablicowej ..................................................................... 237 Zgodno è pomiödzy typowanymi a surowymi listami tablicowymi ............................... 241 Osäony obiektów i autoboxing ...................................................................................... 242 Metody ze zmiennñ liczbñ parametrów ......................................................................... 245 Klasy wyliczeniowe ..................................................................................................... 246 Refleksja ................................................................................................................... 248 Klasa Class .......................................................................................................... 249 Podstawy przechwytywania wyjñtków ....................................................................... 251 Zastosowanie refleksji w analizie funkcjonalno ci klasy ............................................ 253 Refleksja w analizie obiektów w czasie dziaäania programu ....................................... 258 Zastosowanie refleksji w generycznym kodzie tablicowym ......................................... 263 Wska niki do metod .............................................................................................. 267 Porady projektowe dotyczñce dziedziczenia ................................................................... 270 RozdziaÄ 6. Interfejsy i klasy wewnÂtrzne ..........................................................................................273 Interfejsy ................................................................................................................... 274 Wäasno ci interfejsów ............................................................................................ 279 Interfejsy a klasy abstrakcyjne ............................................................................... 280 Klonowanie obiektów .................................................................................................. 281 Interfejsy a sprzö enie zwrotne .................................................................................... 287 Klasy wewnötrzne ....................................................................................................... 290 Dostöp do stanu obiektu w klasie wewnötrznej ........................................................ 292 Specjalne reguäy skäadniowe dotyczñce klas wewnötrznych ....................................... 295 Czy klasy wewnötrzne sñ potrzebne i bezpieczne? .................................................... 296 Lokalne klasy wewnötrzne ..................................................................................... 298 Dostöp do zmiennych finalnych z metod zewnötrznych .............................................. 299 Anonimowe klasy wewnötrzne ................................................................................ 301 Statyczne klasy wewnötrzne ................................................................................... 304 Klasy proxy ................................................................................................................ 307 Wäasno ci klas proxy ............................................................................................. 311
    • Spis treÊci 7 RozdziaÄ 7. Grafika .................................................................................................................................313 Wprowadzenie do pakietu Swing .................................................................................. 314 Tworzenie ramki ......................................................................................................... 317 Pozycjonowanie ramki ................................................................................................. 320 Wäasno ci ramek .................................................................................................. 322 Okre lanie rozmiaru ramki ..................................................................................... 323 Wy wietlanie informacji w komponencie ....................................................................... 327 Figury 2W .................................................................................................................. 331 Kolory ....................................................................................................................... 339 Czcionki .................................................................................................................... 343 Wy wietlanie obrazów ................................................................................................. 351 RozdziaÄ 8. ObsÄuga zdarzeÆ .................................................................................................................355 Podstawy obsäugi zdarzeþ ........................................................................................... 355 Przykäad — obsäuga klikniöcia przycisku .................................................................. 357 Nabywanie biegäo ci w posäugiwaniu siö klasami wewnötrznymi ................................ 362 Tworzenie säuchaczy zawierajñcych jedno wywoäanie metody ..................................... 365 Przykäad — zmiana stylu ........................................................................................ 366 Klasy adaptacyjne ................................................................................................. 370 Akcje ......................................................................................................................... 374 Zdarzenia generowane przez mysz ............................................................................... 381 Hierarchia zdarzeþ w bibliotece AWT ............................................................................ 388 Zdarzenia semantyczne i niskiego poziomu ............................................................. 390 RozdziaÄ 9. Komponenty Swing interfejsu uÑytkownika .....................................................................393 Swing a wzorzec projektowy Model-View-Controller ........................................................ 394 Wzorce projektowe ................................................................................................ 394 Wzorzec Model-View-Controller ............................................................................... 395 Analiza MVC przycisków Swing ............................................................................... 399 Wprowadzenie do zarzñdzania rozkäadem ..................................................................... 400 Rozkäad brzegowy .................................................................................................. 403 Rozkäad siatkowy .................................................................................................. 405 Wprowadzanie tekstu ................................................................................................. 409 Pola tekstowe ....................................................................................................... 409 Etykiety komponentów ........................................................................................... 411 Pola haseä ............................................................................................................ 413 Obszary tekstowe .................................................................................................. 413 Panele przewijane ................................................................................................. 414 Komponenty umo liwiajñce wybór opcji ........................................................................ 417 Pola wyboru .......................................................................................................... 417 Przeäñczniki .......................................................................................................... 420 Obramowanie ....................................................................................................... 424 Listy rozwijalne ..................................................................................................... 428 Suwaki ................................................................................................................. 432 Menu ........................................................................................................................ 438 Tworzenie menu .................................................................................................... 439 Ikony w elementach menu ..................................................................................... 441 Pola wyboru i przeäñczniki jako elementy menu ........................................................ 442 Menu podröczne ................................................................................................... 444 Mnemoniki i akceleratory ....................................................................................... 445
    • 8 Java. Podstawy Aktywowanie i dezaktywowanie elementów menu ..................................................... 448 Paski narzödzi ...................................................................................................... 451 Dymki .................................................................................................................. 453 Zaawansowane techniki zarzñdzania rozkäadem ............................................................ 456 Rozkäad GridBagLayout .......................................................................................... 458 Rozkäad grupowy ................................................................................................... 468 Nieu ywanie adnego zarzñdcy rozkäadu .................................................................. 478 Niestandardowi zarzñdcy rozkäadu .......................................................................... 479 Kolejka dostöpu .................................................................................................... 483 Okna dialogowe ......................................................................................................... 485 Okna dialogowe opcji ............................................................................................ 485 Tworzenie okien dialogowych .................................................................................. 495 Wymiana danych ................................................................................................... 500 Okna dialogowe wyboru plików ............................................................................... 506 Okna dialogowe wyboru kolorów ............................................................................. 517 RozdziaÄ 10. Przygotowywanie apletów i aplikacji do uÑytku ............................................................525 Pliki JAR .................................................................................................................... 526 Manifest .............................................................................................................. 526 Wykonywalne pliki JAR ........................................................................................... 528 Zasoby ................................................................................................................. 529 Pieczötowanie pakietów ......................................................................................... 532 Java Web Start ........................................................................................................... 533 Sandbox ............................................................................................................... 537 Podpisywanie kodu ............................................................................................... 538 API JNLP .............................................................................................................. 539 Aplety ........................................................................................................................ 548 Prosty aplet .......................................................................................................... 549 Znacznik applet i jego atrybuty ............................................................................... 553 Znacznik object ..................................................................................................... 557 Parametry przekazujñce informacje do apletów ........................................................ 557 Dostöp do obrazów i plików audio .......................................................................... 562 rodowisko dziaäania apletu ................................................................................... 563 Zapisywanie preferencji u ytkownika ............................................................................ 572 Mapy wäasno ci .................................................................................................... 572 API Preferences .................................................................................................... 577 RozdziaÄ 11. Wyj¾tki, dzienniki, asercje i debugowanie .......................................................................585 Obsäuga bäödów ......................................................................................................... 586 Klasyfikacja wyjñtków ............................................................................................ 587 Deklarowanie wyjñtków kontrolowanych .................................................................. 589 Zgäaszanie wyjñtków .............................................................................................. 591 Tworzenie klas wyjñtków ........................................................................................ 593 Przechwytywanie wyjñtków ........................................................................................... 594 Przechwytywanie wielu typów wyjñtków .................................................................... 596 Powtórne generowanie wyjñtków i budowanie äaþcuchów wyjñtków ............................ 596 Klauzula finally ..................................................................................................... 597 Analiza danych ze ledzenia stosu .......................................................................... 601 Wskazówki dotyczñce stosowania wyjñtków .................................................................. 604
    • Spis treÊci 9 Asercje ...................................................................................................................... 607 Wäñczanie i wyäñczanie asercji ................................................................................ 608 Zastosowanie asercji w sprawdzaniu parametrów .................................................... 608 Zastosowanie asercji w dokumentacji zaäo eþ ......................................................... 610 Dzienniki ................................................................................................................... 611 Podstawy zapisu do dziennika ................................................................................ 611 Zaawansowane techniki zapisu do dziennika ........................................................... 612 Zmiana konfiguracji mened era dzienników ............................................................. 614 Lokalizacja ........................................................................................................... 615 Obiekty typu Handler ............................................................................................. 616 Filtry .................................................................................................................... 620 Formatery ............................................................................................................. 620 Przepis na dziennik ............................................................................................... 620 Wskazówki dotyczñce debugowania ............................................................................. 629 U ywanie okna konsoli .......................................................................................... 635 ledzenie zdarzeþ AWT .......................................................................................... 636 Zaprzöganie robota AWT do pracy ........................................................................... 640 Praca z debugerem ..................................................................................................... 645 RozdziaÄ 12. Programowanie uogólnione .............................................................................................649 Dlaczego programowanie uogólnione ........................................................................... 650 Dla kogo programowanie uogólnione ...................................................................... 651 Definicja prostej klasy uogólnionej ............................................................................... 652 Metody uogólnione ..................................................................................................... 654 Ograniczenia zmiennych typowych ................................................................................ 655 Kod uogólniony a maszyna wirtualna ............................................................................ 657 Translacja wyra eþ generycznych ............................................................................ 659 Translacja metod uogólnionych .............................................................................. 660 U ywanie starego kodu .......................................................................................... 662 Ograniczenia i braki .................................................................................................... 663 Nie mo na podawaè typów prostych jako parametrów typowych ................................ 663 Sprawdzanie typów w czasie dziaäania programu jest mo liwe tylko dla typów surowych ............................................................................................ 663 Obiektów klasy uogólnionej nie mo na generowaè ani przechwytywaè ........................ 664 Nie mo na tworzyè tablic typów uogólnionych .......................................................... 665 Nie wolno tworzyè egzemplarzy zmiennych typowych ................................................. 665 Zmiennych typowych nie mo na u ywaè w statycznych kontekstach klas uogólnionych ... 667 Uwa aj na konflikty, które mogñ powstaè po wymazaniu typów .................................. 667 Zasady dziedziczenia dla typów uogólnionych ................................................................ 668 Typy wieloznaczne ...................................................................................................... 671 Ograniczenia nadtypów typów wieloznacznych .......................................................... 672 Typy wieloznaczne bez ograniczeþ .......................................................................... 674 Chwytanie typu wieloznacznego .............................................................................. 675 Refleksja a typy uogólnione ......................................................................................... 679 Zastosowanie parametrów Class<T> do dopasowywania typów ................................. 680 Informacje o typach generycznych w maszynie wirtualnej .......................................... 680
    • 10 Java. Podstawy RozdziaÄ 13. Kolekcje .............................................................................................................................687 Interfejsy kolekcyjne ................................................................................................... 687 Oddzielenie warstwy interfejsów od warstwy klas konkretnych ................................... 688 Interfejsy Collection i Iterator ................................................................................. 690 Konkretne klasy kolekcyjne ......................................................................................... 696 Listy powiñzane .................................................................................................... 696 Listy tablicowe ...................................................................................................... 706 Zbiór HashSet ...................................................................................................... 706 Zbiór TreeSet ........................................................................................................ 710 Porównywanie obiektów ......................................................................................... 711 Kolejki Queue i Deque ........................................................................................... 717 Kolejki priorytetowe ............................................................................................... 718 Mapy ................................................................................................................... 719 Specjalne klasy Set i Map ..................................................................................... 724 Architektura kolekcji ................................................................................................... 729 Widoki i obiekty opakowujñce ................................................................................. 733 Operacje zbiorcze .................................................................................................. 739 Konwersja pomiödzy kolekcjami a tablicami ............................................................ 740 Algorytmy ................................................................................................................... 741 Sortowanie i tasowanie ......................................................................................... 742 Wyszukiwanie binarne ........................................................................................... 745 Proste algorytmy ................................................................................................... 746 Pisanie wäasnych algorytmów ................................................................................. 748 Stare kolekcje ............................................................................................................ 749 Klasa Hashtable ................................................................................................... 749 Wyliczenia ............................................................................................................ 750 Mapy wäasno ci .................................................................................................... 751 Stosy ................................................................................................................... 751 Zbiory bitów .......................................................................................................... 752 RozdziaÄ 14. Wielow¾tkowoÊÀ ...............................................................................................................757 Czym sñ wñtki ............................................................................................................ 758 Wykonywanie zadaþ w osobnych wñtkach ................................................................ 763 Przerywanie wñtków .................................................................................................... 769 Stany wñtków ............................................................................................................. 771 Wñtki NEW ........................................................................................................... 772 Wñtki RUNNABLE .................................................................................................. 772 Wñtki BLOCKED i WAITING ..................................................................................... 773 Zamykanie wñtków ................................................................................................ 773 Wäasno ci wñtków ...................................................................................................... 775 Priorytety wñtków .................................................................................................. 775 Wñtki demony ....................................................................................................... 776 Procedury obsäugi nieprzechwyconych wyjñtków ....................................................... 777 Synchronizacja ........................................................................................................... 778 Przykäad sytuacji powodujñcej wy cig ...................................................................... 778 Wy cigi ................................................................................................................ 783 Obiekty klasy Lock ................................................................................................ 784 Warunki ............................................................................................................... 787 Säowo kluczowe synchronized ................................................................................. 792 Bloki synchronizowane .......................................................................................... 796 Monitor ................................................................................................................ 797
    • Spis treÊci 11 Pola ulotne ........................................................................................................... 798 Zakleszczenia ....................................................................................................... 800 Testowanie blokad i odmierzanie czasu .................................................................. 803 Blokady odczytu-zapisu .......................................................................................... 804 Dlaczego metody stop i suspend sñ odradzane ....................................................... 805 Kolejki blokujñce ........................................................................................................ 808 Kolekcje bezpieczne wñtkowo ...................................................................................... 815 Szybkie mapy, zbiory i kolejki ................................................................................. 815 Tablice kopiowane przy zapisie ............................................................................... 817 Starsze kolekcje bezpieczne wñtkowo ..................................................................... 817 Interfejsy Callable i Future ........................................................................................... 819 Klasa Executors ......................................................................................................... 823 Pule wñtków ......................................................................................................... 824 Planowanie wykonywania ....................................................................................... 828 Kontrolowanie grup zadaþ ...................................................................................... 829 Synchronizatory .......................................................................................................... 830 Semafory ............................................................................................................. 830 Klasa CountDownLatch .......................................................................................... 831 Bariery ................................................................................................................. 832 Klasa Exchanger ................................................................................................... 833 Kolejki synchroniczne ............................................................................................ 833 Przykäad — wstrzymywanie i ponowne uruchamianie animacji ................................... 833 Wñtki a biblioteka Swing ............................................................................................. 839 Uruchamianie czasochäonnych zadaþ ...................................................................... 840 Klasa SwingWorker ............................................................................................... 845 Zasada jednego wñtku .......................................................................................... 851 Dodatek A SÄowa kluczowe Javy ..........................................................................................................853 Skorowidz .............................................................................................................................................855
    • 8 ObsÄuga zdarzeÆ W tym rozdziale: Q Podstawy obsáugi zdarze Q Akcje Q Zdarzenia generowane przez mysz Q Hierarchia zdarze AWT Obsáuga zdarze ma fundamentalne znaczenie w programach z graficznym interfejsem u yt- kownika. Ka dy, kto chce tworzyü interfejsy graficzne w Javie, musi opanowaü obsáug zda- rze . Niniejszy rozdziaá opisuje model obsáugi zdarze biblioteki AWT. Do opisywanych zagadnie nale przechwytywanie zdarze w komponentach interfejsu u ytkownika i urz - dzeniach wej ciowych, a tak e akcje (ang. actions), czyli bardziej strukturalna metoda przetwarzania zdarze . Podstawy obsÄugi zdarzeÆ Ka dy system operacyjny posiadaj cy graficzny interfejs u ytkownika stale monitoruje za- chodz ce w nim zdarzenia, jak naciskanie klawiszy na klawiaturze czy klikni cia przyciskiem myszy. Informacje o tych zdarzeniach s przesyáane do uruchomionych programów. Nast p- nie ka dy program podejmuje samodzieln decyzj , w jaki sposób, je li w ogóle, zareagowaü na te zdarzenia. W takich j zykach jak Visual Basic relacje pomi dzy zdarzeniami a kodem s oczywiste. Programista pisze kod obsáugi ka dego interesuj cego go zdarzenia i umieszcza go w tzw. procedurze obsáugi zdarze (ang. event procedure). Na przykáad z przyciskiem o nazwie HelpButton w j zyku Visual Basic mo e byü skojarzona procedura obsáugi zdarze o nazwie HelpButton_Click. Kod niniejszej procedury jest wykonywany w odpowiedzi na ka de klikni cie niniejszego przycisku. Ka dy komponent GUI w j zyku Visual Basic reaguje na ustalony zestaw zdarze — nie mo na zmieniü zdarze , na które reaguje dany komponent.
    • 356 Java. Podstawy Natomiast programi ci czystego j zyka C zajmuj cy si zdarzeniami musz pisaü procedury nieprzerwanie monitoruj ce kolejk zdarze w celu sprawdzenia, jakie powiadomienia prze- syáa system operacyjny (z reguáy do tego celu stosuje si p tl zawieraj c bardzo rozbudowan instrukcj switch!). Technika ta jest oczywi cie bardzo maáo elegancka i sprawia wiele pro- blemów podczas pisania kodu. Jej zalet jest natomiast to, e nie ma adnych ogranicze dotycz cych zdarze , na które mo na reagowaü, w przeciwie stwie do innych j zyków, np. Visual Basica, które wkáadaj bardzo du o wysiáku w ukrywanie kolejki zdarze przed programist . W rodowisku programistycznym Javy przyj to podej cie po rednie pomi dzy j zykami Visual Basic a C, je li chodzi o oferowane mo liwo ci, a co za tym idzie — tak e záo ono ü. Poru- szaj c si w zakresie zdarze , które obsáuguje biblioteka AWT, programista ma peán kontrol nad sposobem przesyáania zdarze ze ródeá zdarze (ang. event sources), np. przycisków lub pasków przewijania, do sáuchaczy zdarze (ang. event listener). Na sáuchacza zdarze mo na desygnowaü ka dy obiekt — w praktyce wybiera si ten obiekt, który z áatwo ci mo e wy- konaü odpowiednie dziaáania w odpowiedzi na zdarzenie. Ten delegacyjny model zdarze daje znacznie wi ksze mo liwo ci ni j zyk Visual Basic, w którym sáuchacz jest ustalony z góry. ródáa zdarze dysponuj metodami, w których mo na rejestrowaü sáuchaczy zdarze . Kiedy ma miejsce okre lone zdarzenie, ródáo wysyáa powiadomienie o nim do wszystkich obiektów nasáuchuj cych, które zostaáy dla niego zarejestrowane. Jak mo na si spodziewaü, informacje o zdarzeniu w j zyku obiektowym, takim jak Java, s pakowane w obiekcie zdarze (ang. event object). W Javie wszystkie obiekty zdarze nale do klasy java.util.EventObject. Oczywi cie istniej te podklasy reprezentuj ce ka dy typ zdarzenia, takie jak ActionEvent czy WindowEvent. Ró ne ródáa zdarze mog dostarczaü ró nego rodzaju zdarze . Na przykáad przycisk mo e wysyáaü obiekty ActionEvent, podczas gdy okno wysyáa obiekty WindowEvent. Podsumujmy, co ju wiemy na temat obsáugi zdarze w bibliotece AWT: Q Obiekt nasáuchuj cy jest egzemplarzem klasy implementuj cej specjalny interfejs nasáuchu (ang. listener interface). Q ródáo zdarze to obiekt, który mo e rejestrowaü obiekty nasáuchuj ce i wysyáaü do nich obiekty zdarze . Q ródáo zdarze wysyáa obiekty zdarze do wszystkich zarejestrowanych sáuchaczy w chwili wyst pienia zdarzenia. Q Informacje zawarte w obiekcie zdarze s wykorzystywane przez obiekty nasáuchuj ce przy podejmowaniu decyzji dotycz cej reakcji na zdarzenie. Rysunek 8.1 przedstawia relacje pomi dzy klasami obsáugi zdarze a interfejsami Poni ej znajduje si przykáadowa definicja sáuchacza: ActionListener listener = . . .; JButton button = new JButton("Ok"); button.addActionListener(listener);
    • RozdziaÄ 8. Q ObsÄuga zdarzeÆ 357 Rysunek 8.1. Relacje pomiödzy ródäami zdarzeþ a säuchaczami Od tej pory obiekt listener b dzie powiadamiany o ka dym zdarzeniu akcji w przycisku. Jak si mo na domy liü, zdarzenie akcji w przypadku przycisku to jego klikni cie. Klasa implementuj ca interfejs ActionListener musi definiowaü metod o nazwie action- Performed, która jako parametr przyjmuje obiekt typu ActionEvent: class MyListener implements ActionListener { . . . public void actionPerformed(ActionEvent event) { // Instrukcje wykonywane w odpowiedzi na klikni cie przycisku. . . . } } Kiedy u ytkownik kliknie przycisk, obiekt typu JButton tworzy obiekt typu ActionEvent i wywoáuje metod listener.actionPerformed(event), przekazuj c do niej niniejszy obiekt zdarzenia. ródáo zdarze , takie jak przycisk, mo e mieü kilku sáuchaczy. W takim przy- padku klikni cie przycisku przez u ytkownika powoduje wywoáanie metod actionPerformed wszystkich sáuchaczy. Rysunek 8.2 przedstawia relacje pomi dzy ródáem zdarze , sáuchaczem zdarze a obiek- tem zdarze . PrzykÄad — obsÄuga klikniÂcia przycisku Aby nabraü biegáo ci w posáugiwaniu si modelem delegacji zdarze , przeanalizujemy szcze- góáowo prosty program reaguj cy na klikni cie przycisku. Utworzymy panel zawieraj cy trzy przyciski, których zdarze b d nasáuchiwaü trzy obiekty nasáuchuj ce. W tym przypadku za ka dym razem, gdy u ytkownik kliknie jeden z przycisków na panelu, skojarzony z tym przyciskiem obiekt odbierze obiekt typu ActionEvent oznaczaj cy klikni cie przycisku. W odpowiedzi obiekt nasáuchuj cy zmieni kolor táa panelu. Przed przej ciem do programu, który nasáuchuje klikni ü przycisków, musimy najpierw za- poznaü si z technik tworzenia i dodawania przycisków do panelu (wi cej informacji na temat elementów GUI znajduje si w rozdziale 9.).
    • 358 Java. Podstawy Rysunek 8.2. Powiadamianie o zdarzeniach Tworzenie przycisku polega na podaniu jego konstruktorowi áa cucha okre laj cego etykiet przycisku, ikony lub jednego i drugiego. Poni ej znajduj si przykáady tworzenia dwóch przycisków: JButton yellowButton = new JButton(" ó ty"); JButton blueButton = new JButton(new ImageIcon("blue-ball.gif")); Przyciski do panelu dodaje si za pomoc metody add: JButton yellowButton = new JButton(" ó ty"); JButton blueButton = new JButton("Niebieski"); JButton redButton = new JButton("Czerwony"); buttonPanel.add(yellowButton); buttonPanel.add(blueButton); buttonPanel.add(redButton); Wynik powy szych dziaáa przedstawia rysunek 8.3. Nast pnie konieczne jest dodanie procedur nasáuchuj cych tych przycisków. Do tego po- trzebne s klasy implementuj ce interfejs ActionListener, który, jak ju wspominali my, zawiera tylko jedn metod : actionPerformed. Sygnatura niniejszej metody jest nast puj ca: public void actionPerformed(ActionEvent event)
    • RozdziaÄ 8. Q ObsÄuga zdarzeÆ 359 Rysunek 8.3. Panel z przyciskami Interfejs ActionListener nie ogranicza siö tylko do klikniöè przycisków. Znajduje on zastosowanie w wielu innych sytuacjach, takich jak: Q wybór elementu z pola listy za pomocñ dwukrotnego klikniöcia, Q wybór elementu menu, Q klikniöcie klawisza Enter w polu tekstowym, Q upäyw okre lonej ilo ci czasu dla komponentu Timer. Wiöcej szczegóäów na ten temat znajduje siö w niniejszym i kolejnym rozdziale. Sposób u ycia interfejsu ActionListener jest taki sam we wszystkich sytuacjach: metoda actionPerformed (jedyna w interfejsie ActionListener) przyjmuje obiekt typu ActionEvent jako parametr. Ten obiekt zdarzenia dostarcza informacji o zdarzeniu, które miaäo miejsce. Reakcj na klikni cie przycisku ma byü zmiana koloru táa panelu. dany kolor b dziemy przechowywaü w klasie nasáuchuj cej: class ColorAction implements ActionListener { public ColorAction(Color c) { backgroundColor = c; } public void actionPerformed(ActionEvent event) { // Ustawienie koloru táa panelu. . . . } private Color backgroundColor; } Nast pnie dla ka dego koloru tworzymy osobny obiekt i ka dy z nich rejestrujemy jako sáuchacza przycisku. ColorAction yellowAction = new ColorAction(Color.YELLOW); ColorAction blueAction = new ColorAction(Color.BLUE); ColorAction redAction = new ColorAction(Color.RED); yellowButton.addActionListener(yellowAction); blueButton.addActionListener(blueAction); redButton.addActionListener(redAction);
    • 360 Java. Podstawy Je li u ytkownik kliknie na przykáad przycisk z napisem ó ty, zostanie wywoáana metoda actionPerformed obiektu yellowAction. Pole backgroundColor niniejszego obiektu ma warto ü color.YELLOW. Zostaá jeszcze tylko jeden problem do rozwi zania. Obiekt typu ColorAction nie ma dost - pu do zmiennej buttonPanel. Mo na to rozwi zaü na jeden z dwóch sposobów. Mo na za- pisaü panel w obiekcie ColorAction i skonstruowaü go w konstruktorze ColorAction. Wygod- niej jednak byáoby, gdyby ColorAction byáa klas wewn trzn klasy ButtonFrame. Dzi ki temu jej metody miaáyby automatycznie dost p do zewn trznego panelu (wi cej informacji na temat klas wewn trznych znajduje si w rozdziale 6.). Zastosujemy drug z opisanych metod. Poni ej przedstawiamy klas ColorAction wewn trz klasy ButtonFrame: class ButtonPanel extends JFrame { . . . private class ColorAction implements ActionListener { . . . public void actionPerformed(ActionEvent event) { buttonPanel.setBackground(backgroundColor); } private Color backgroundColor; } private JPanel buttonPanel; } Przypatrzmy si uwa niej metodzie actionPerformed. Klasa ColorAction nie posiada pola buttonPanel. Ma go natomiast zewn trzna klasa ButtonFrame. Jest to bardzo cz sto spotykana sytuacja. Obiekty nasáuchu zdarze cz sto musz wykony- waü dziaáania, które maj wpáyw na inne obiekty. Klas nasáuchuj c cz sto mo na umie ciü w strategicznym miejscu wewn trz klasy, której obiekt ma mieü zmieniony stan. Listing 8.1 przedstawia kompletny program. Klikni cie jednego z przycisków powoduje zmian koloru táa panelu przez odpowiedniego sáuchacza akcji. Listing 8.1. ButtonTest.java import java.awt.*; import java.awt.event.*; import javax.swing.*; /** * @version 1.33 2007-06-12 * @author Cay Horstmann */ public class ButtonTest {
    • RozdziaÄ 8. Q ObsÄuga zdarzeÆ 361 public static void main(String[] args) { EventQueue.invokeLater(new Runnable() { public void run() { ButtonFrame frame = new ButtonFrame(); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); } }); } } /** * Ramka z panelem zawieraj cym przyciski. */ class ButtonFrame extends JFrame { public ButtonFrame() { setTitle("ButtonTest"); setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT); // Tworzenie przycisków. JButton yellowButton = new JButton(" ó ty"); JButton blueButton = new JButton("Niebieski"); JButton redButton = new JButton("Czerwony"); buttonPanel = new JPanel(); // Dodanie przycisków do panelu. buttonPanel.add(yellowButton); buttonPanel.add(blueButton); buttonPanel.add(redButton); // Dodanie panelu do ramki. add(buttonPanel); // Utworzenie akcji przycisków. ColorAction yellowAction = new ColorAction(Color.YELLOW); ColorAction blueAction = new ColorAction(Color.BLUE); ColorAction redAction = new ColorAction(Color.RED); // Powi zanie akcji z przyciskami. yellowButton.addActionListener(yellowAction); blueButton.addActionListener(blueAction); redButton.addActionListener(redAction); } /** * Sáuchacz akcji ustawiaj cy kolor táa panelu. */ private class ColorAction implements ActionListener {
    • 362 Java. Podstawy public ColorAction(Color c) { backgroundColor = c; } public void actionPerformed(ActionEvent event) { buttonPanel.setBackground(backgroundColor); } private Color backgroundColor; } private JPanel buttonPanel; public static final int DEFAULT_WIDTH = 300; public static final int DEFAULT_HEIGHT = 200; } javax.swing.JButton 1.2 Q JButton(String label) Q JButton(Icon icon) Q JButton(String label, Icon icon) Tworzy przycisk. àa cuch etykiety mo e zawieraü sam tekst lub (od Java SE 1.3) kod HTML, np. "<html><b>Ok</b></html>". java.awt.Container 1.0 Q Component add(Component c) Dodaje komponent c do kontenera. javax.swing.ImageIcon 1.2 Q ImageIcon(String filename) Tworzy ikon , której obraz jest zapisany w pliku. Nabywanie biegÄoÊci w posÄugiwaniu si klasami wewnÂtrznymi Niektórzy programi ci nie przepadaj za klasami wewn trznymi, poniewa uwa aj , e klasy i obiekty o du ych rozmiarach spowalniaj dziaáanie programu. Przyjrzyjmy si temu twier- dzeniu. Nie potrzebujemy nowej klasy dla ka dego elementu interfejsu u ytkownika. W na- szym programie wszystkie trzy przyciski wspóádziel jedn klas nasáuchuj c . Oczywi cie ka dy z nich posiada osobny obiekt nasáuchuj cy. Ale obiekty te nie s du e. Ka dy z nich zawiera warto ü okre laj c kolor i referencj do panelu. A tradycyjne rozwi zanie, z zasto- sowaniem instrukcji if-else, równie odwoáuje si do tych samych obiektów kolorów prze- chowywanych przez sáuchaczy akcji, tylko e jako zmienne lokalne, a nie pola obiektów.
    • RozdziaÄ 8. Q ObsÄuga zdarzeÆ 363 Poni ej przedstawiamy dobry przykáad tego, jak anonimowe klasy wewn trzne mog upro- ciü kod programu. W programie na listingu 8.1 z ka dym przyciskiem zwi zane s takie same dziaáania: 1. Utworzenie przycisku z etykiet . 2. Dodanie przycisku do panelu. 3. Utworzenie sáuchacza akcji z odpowiednim kolorem. 4. Dodanie sáuchacza akcji. Napiszemy metod pomocnicz , która b dzie upraszczaáa niniejsze czynno ci: public void makeButton(String name, Color backgroundColor) { JButton button = new JButton(name); buttonPanel.add(button); ColorAction action = new ColorAction(backgroundColor); button.addActionListener(action); } Teraz wystarcz tylko nast puj ce wywoáania: makeButton(" ó ty", Color.YELLOW); makeButton("niebieski", Color.BLUE); makeButton("czerwony", Color.RED); Mo liwe s dalsze uproszczenia. Zauwa my, e klasa ColorAction jest potrzebna tylko jeden raz — w metodzie makeButton. A zatem mo na j przerobiü na klas anonimow : public void makeButton(String name, final Color backgroundColor) { JButton button = new JButton(name); buttonPanel.add(button); button.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent event) { buttonPanel.setBackground(backgroundColor); } }); } Kod sáuchacza akcji staá si znacznie prostszy. Metoda actionPerformed odwoáuje si do zmiennej parametrycznej backgroundColor (podobnie jak w przypadku wszystkich zmiennych lokalnych wykorzystywanych w klasie wewn trznej, parametr ten musi byü finalny). Nie jest potrzebny aden jawny konstruktor. Jak widzieli my w rozdziale 6., mechanizm klas wewn trznych automatycznie generuje konstruktor zapisuj cy wszystkie finalne zmienne lokalne, które s u ywane w jednej z metod klasy wewn trznej.
    • 364 Java. Podstawy Anonimowe klasy wewnötrzne potrafiñ zmyliè niejednego programistö. Mo na jed- nak przyzwyczaiè siö do ich rozszyfrowywania, wyrabiajñc sobie umiejötno è po- mijania wzrokiem kodu procedury: button.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent event) { buttonPanel.setBackground(backgroundColor); } }); Akcja przycisku ustawia kolor täa. Dopóki procedura obsäugi zdarzeþ skäada siö z tylko kilku instrukcji, wydaje siö, e z odczytem nie powinno byè problemów, zwäaszcza je li w sferze naszych zainteresowaþ nie le ñ mechanizmy klas wewnötrznych. Säuchaczem przycisku mo e byè obiekt ka dej klasy, która implementuje interfejs ActionListener. My wolimy u ywaè obiektów nowej klasy, która zostaäa utworzona specjalnie z my lñ o wykonywaniu akcji przycisku. Jednak niektórzy programi ci nie czujñ siö pewnie w stosowaniu klas wewnötrznych i wybierajñ inne podej cie. Implementujñ interfejs ActionListener w kontenerze ródeä zdarzeþ. Nastöpnie kontener ten ustawia sam siebie jako säuchacza w nastöpujñcy sposób: yellowButton.addActionListener(this); blueButton.addActionListener(this); redButton.addActionListener(this); W tej sytuacji aden z trzech przycisków nie ma osobnego säuchacza. Dysponujñ one wspólnym obiektem, którym jest ramka przycisku. W zwiñzku z tym metoda action- Performed musi sprawdziè, który przycisk zostaä klikniöty. class ButtonFrame extends JFrame implements ActionListener { . . . public void actionPerformed(ActionEvent event) { Object source = event.getSource(); if (source == yellowButton) . . . else if (source == blueButton) . . . else if (source == redButton ) . . . else . . . } } Jak widaè, metoda ta jest nieco zagmatwana, przez co nie zalecamy jej stosowania. java.util.EventObject 1.1 Q Object setSource() Zwraca referencj do obiektu, w którym wyst piáo zdarzenie.
    • RozdziaÄ 8. Q ObsÄuga zdarzeÆ 365 java.awt.event.ActionEvent 1.1 Q String getActionCommand() Zwraca áa cuch polecenia skojarzonego z danym zdarzeniem akcji. Je li zdarzenie pochodzi od przycisku, áa cuch polecenia jest taki sam jak etykieta przycisku, chyba e zostaá zmieniony za pomoc metody setActionCommand. java.beans.EventHandler 1.4 Q static Object create(Class listenerInterface, Object target, String action) Q static Object create(Class listenerInterface, Object target, String action, String eventProperty) Q static Object create(Class listenerInterface, Object target, String action, String eventProperty, String listenerMethod) Tworzy obiekt klasy po rednicz cej implementuj cej dany interfejs. Albo podana metoda, albo wszystkie metody interfejsu wykonuj dane akcje na rzecz obiektu docelowego. Akcj mo e byü metoda lub wáasno ü obiektu docelowego. Je li jest to wáasno ü, wykonywana jest jej metoda ustawiaj ca. Na przykáad akcja text jest zamieniana na wywoáanie metody setText. Wáasno ü zdarzenia skáada si z jednej lub wi kszej liczby nazw wáasno ci oddzielonych kropkami. Pierwsza wáasno ü jest wczytywana z parametru metody nasáuchuj cej. Druga wáasno ü pochodzi od powstaáego obiektu itd. Wynik ko cowy staje si parametrem akcji. Na przykáad wáasno ü source.text jest zamieniana na wywoáania metod getSource i getText. Tworzenie sÄuchaczy zawieraj¾cych jedno wywoÄanie metody W Java SE 1.4 wprowadzono mechanizm umo liwiaj cy okre lanie prostych sáuchaczy zda- rze bez tworzenia klas wewn trznych. Wyobra my sobie na przykáad, e mamy przycisk z etykiet Load, którego procedura obsáugi zdarze zawiera tylko jedn metod : frame.loadData(); Oczywi cie mo na u yü anonimowej klasy wewn trznej: loadButton.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent event) { frame.loadData(); } }); Ale klasa EventHandler mo e utworzyü takiego sáuchacza automatycznie, za pomoc nast - puj cego wywoáania: EventHandler.create(ActionListener.class, frame, "loadData")
    • 366 Java. Podstawy Oczywi cie nadal konieczne jest zainstalowanie procedury obsáugi: loadButton.addActionListener( EventHandler.create(ActionListener.class, frame, "loadData")); Je li sáuchacz wywoáuje metod z jednym parametrem, który mo na uzyskaü z parametru zdarzenia, mo na u yü innego rodzaju metody create. Na przykáad wywoáanie: EventHandler.create(ActionListener.class, frame, "loadData", "source.text") jest równoznaczne z: new ActionListener() { public void actionPerformed(ActionEvent event) { frame.loadData(((JTextField) event.getSource()).getText()); } } Nazwy wáasno ci source i text zamieniaj si w wywoáania metod getSource i getText. PrzykÄad — zmiana stylu Domy lnym stylem programów pisanych przy u yciu Swinga jest Metal. Istniej dwa spo- soby na zmian stylu. Pierwszy z nich polega na utworzeniu pliku swing.properties w katalogu jre/lib w miejscu instalacji Javy. W pliku tym nale y ustawiü wáasno ü swing.defaultlaf na nazw klasy stylu, który chcemy zastosowaü. Na przykáad: swing.defaultlaf=com.sun.java.swing.plaf.motif.MotifLookAndFeel Zauwa my, e styl Metal jest zlokalizowany w pakiecie javax.swing. Pozostaáe style znaj- duj si w pakiecie com.sun.java i nie musz byü obecne w ka dej implementacji Javy. Obec- nie ze wzgl du na prawa autorskie pakiety stylów systemów Windows i Macintosh s dost pne wyá cznie z wersjami rodowiska uruchomieniowego Javy przeznaczonymi dla tych systemów. Poniewa w plikach wäasno ci linie zaczynajñce siö od znaku # sñ ignorowane, mo na w takim pliku umie ciè kilka stylów i wybieraè je wedle upodobania, odpo- wiednio zmieniajñc poäo enie znaku #: #swing.defaultlaf=javax.swing.plaf.metal.MetalLookAndFeel swing.defaultlaf=com.sun.java.swing.plaf.motif.MotifLookAndFeel #swing.defaultlaf=com.sun.java.swing.plaf.windows.WindowsLookAndFeel Aby zmieniè styl w ten sposób, konieczne jest ponowne uruchomienie programu. Pro- gramy Swing wczytujñ plik swing.properties tylko jeden raz — przy uruchamianiu. Drugi sposób polega na dynamicznej zmianie stylu. Nale y wywoáaü statyczn metod UIManager.setLookAndFeel oraz przekazaü do niej nazw klasy wybranego stylu. Nast pnie wywoáujemy statyczn metod SwingUtilities.updateComponentTreeUI w celu od wie enia caáego zbioru komponentów. Metodzie tej wystarczy przekazaü tylko jeden komponent, a po- zostaáe znajdzie ona samodzielnie. Metoda UIManager.setLookAndFeel mo e spowodowaü
    • RozdziaÄ 8. Q ObsÄuga zdarzeÆ 367 kilka wyj tków, je li nie znajdzie danego stylu lub je li wyst pi bá d podczas áadowania stylu. Jak zwykle nie zgá biamy kodu obsáuguj cego wyj tki, poniewa szczegóáowo zajmie- my si tym w rozdziale 11. Poni szy przykáadowy fragment programu przedstawia sposób przeá czenia na styl Motif: String plaf = "com.sun.java.swing.plaf.motif.MotifLookAndFeel"; try { UIManager.setLookAndFeel(plaf); SwingUtilities.updateComponentTreeUI(panel); } catch(Exception e) { e.printStackTrace(); } Aby odnale ü wszystkie zainstalowane style, nale y u yü wywoáania: UIManager.LookAndFeelInfo[] infos = UIManager.getInstalledLookAndFeels(); W takiej sytuacji nazw ka dego stylu i jego klasy mo na uzyskaü nast puj co: String name = infos[i].getName(); String className = infos[i].getClassName(); Listing 8.2 przedstawia peány kod programu demonstruj cego przeá czanie stylów (zobacz rysunek 8.4). Program ten jest podobny do programu z listingu 8.1. Id c za rad z poprzed- niej sekcji, akcj przycisku, polegaj c na zmianie stylu, okre lili my za pomoc metody pomocniczej makeButton i anonimowej klasy wewn trznej. Listing 8.2. PlafTest.java import java.awt.EventQueue; import java.awt.event.*; import javax.swing.*; /** * @version 1.32 2007-06-12 * @author Cay Horstmann */ public class PlafTest { public static void main(String[] args) { EventQueue.invokeLater(new Runnable() { public void run() { PlafFrame frame = new PlafFrame(); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); } }); } }
    • 368 Java. Podstawy /** * Ramka z panelem zawieraj cym przyciski zmieniaj ce styl. */ class PlafFrame extends JFrame { public PlafFrame() { setTitle("PlafTest"); setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT); buttonPanel = new JPanel(); UIManager.LookAndFeelInfo[] infos = UIManager.getInstalledLookAndFeels(); for (UIManager.LookAndFeelInfo info : infos) makeButton(info.getName(), info.getClassName()); add(buttonPanel); } /** * Tworzy przycisk zmieniaj cy styl. * @param name nazwa przycisku * @param plafName nazwa klasy stylu */ void makeButton(String name, final String plafName) { // Dodanie przycisku do panelu. JButton button = new JButton(name); buttonPanel.add(button); // Ustawienie akcji przycisku. button.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent event) { // Akcja przycisku — przeá czenie na nowy styl. try { UIManager.setLookAndFeel(plafName); SwingUtilities.updateComponentTreeUI(PlafFrame.this); } catch (Exception e) { e.printStackTrace(); } } }); } private JPanel buttonPanel; public static final int DEFAULT_WIDTH = 300; public static final int DEFAULT_HEIGHT = 200; }
    • RozdziaÄ 8. Q ObsÄuga zdarzeÆ 369 Rysunek 8.4. Zmienianie stylu Jedna rzecz w niniejszym programie jest godna szczególnej uwagi. Metoda actionPerformed wewn trznej klasy nasáuchuj cej akcji musi przekazaü referencj this klasy zewn trznej PlafFrame do metody updateComponentTreeUI. Przypomnijmy sobie z rozdziaáu 6., e przed wska nikiem this obiektu klasy zewn trznej musi znajdowaü si przedrostek w postaci na- zwy klasy zewn trznej: SwingUtilities.updateComponentTreeUI(PlafPanel.this); javax.swing.UIManager 1.2 Q static UIManager.LookAndFeelInfo[] getInstalledLookAndFeels() Tworzy tablic obiektów reprezentuj cych zainstalowane style. Q static setLookAndFeel(String className) Ustawia aktualny styl, wykorzystuj c do tego podan nazw klasy (np. javax.swing.plaf.metal.MetalLookAndFeel). javax.swing.UIManager.LookAndFeelInfo 1.2 Q String getName() Zwraca nazw stylu. Q String getClassName() Zwraca nazw klasy implementuj cej dany styl.
    • 370 Java. Podstawy Klasy adaptacyjne Nie wszystkie zdarzenia s tak áatwe w obsáudze jak klikni cie przycisku. W profesjonalnym programie nale y stale sprawdzaü, czy u ytkownik nie zamyka gáównej ramki, aby zapo- biec ewentualnej utracie jego danych. Gdy u ytkownik zamyka ramk , powinno wy wietlaü si okno dialogowe monituj ce o potwierdzenie niniejszego zamiaru. Kiedy u ytkownik zamyka okno, obiekt klasy JFrame jest ródáem zdarzenia WindowEvent. Aby przechwyciü to zdarzenie, konieczny jest odpowiedni obiekt nasáuchuj cy, który nale y dodaü do listy sáuchaczy okna ramki. WindowListener listener = . . .; frame.addWindowListener(listener); Obiekt nasáuchuj cy okna musi nale eü do klasy implementuj cej interfejs WindowListener. Interfejs ten zawiera siedem metod. Ramka wywoáuje jedn z nich w odpowiedzi na jedno z siedmiu zdarze , które mog mieü miejsce w przypadku okna. Nazwy tych metod mówi same za siebie. Nale y tylko wyja niü, e iconfied w systemie Windows oznacza to samo co minimized. Poni ej widaü caáy interfejs WindowListener: public interface WindowListener { void windowOpened(WindowEvent e); void windowClosing(WindowEvent e); void windowClosed(WindowEvent e); void windowIconified(WindowEvent e); void windowDeiconified(WindowEvent e); void windowActivated(WindowEvent e); void windowDeactivated(WindowEvent e); } Aby sprawdziè, czy okno zostaäo zmaksymalizowane, nale y zainstalowaè obiekt WindowStateListener. Zobacz wyciñg z API na stronie 373. W Javie klasa, która implementuje dany interfejs, musi definiowaü wszystkie jego metody. W tym przypadku oznacza to implementacj siedmiu metod. Przypomnijmy jednak, e inte- resuje nas tylko jedna z nich, o nazwie windowClosing. Oczywi cie nic nie stoi na przeszkodzie, aby zaimplementowaü niniejszy interfejs, wstawiü wywoáanie System.exit(0) do metody windowClosing i napisaü sze ü nicnierobi cych funkcji dla pozostaáych metod: class Terminator implements WindowListener { public void windowClosing(WindowEvent e) { if (u ytkownik potwierdza) System.exit(0); } public void windowOpened(WindowEvent e) {} public void windowClosed(WindowEvent e) {} public void windowIconified(WindowEvent e) {}
    • RozdziaÄ 8. Q ObsÄuga zdarzeÆ 371 public void windowDeiconified(WindowEvent e) {} public void windowActivated(WindowEvent e) {} public void windowDeactivated(WindowEvent e) {} } Pisanie sze ciu metod, które nic nie robi , jest tym rodzajem pracy, której nikt nie lubi. Za- danie to uáatwiaj klasy adaptacyjne (ang. adapter class) dost pne z ka dym interfejsem nasáuchuj cym w bibliotece AWT, który ma wi cej ni jedn metod . Klasy te implementuj wszystkie metody interfejsów, którym odpowiadaj , ale metody te nic nie robi . Na przykáad klasa WindowAdapter zawiera definicje siedmiu nicnierobi cych metod. Oznacza to, e klasa adaptacyjna automatycznie speánia wymagania techniczne stawiane przez Jav , a dotycz ce implementacji odpowiadaj cego jej interfejsu nasáuchuj cego. Klas adaptacyjn mo na roz- szerzyü, definiuj c w podklasie metody odpowiadaj ce niektórym, ale nie wszystkim typom zdarze interfejsu (interfejsy, które maj tylko jedn metod , np. ActionListener, nie po- trzebuj metod adaptacyjnych). Rozszerzymy klas WindowAdapter. Odziedziczymy po niej sze ü nicnierobi cych metod, a metod windowClossing przesáonimy: class Terminator extends WindowAdapter { public void windowClosing(WindowEvent e) { if (u ytkownik potwierdza) System.exit(0); } } Teraz mo emy zarejestrowaü obiekt typu Terminator jako sáuchacza zdarze : WindowListener listener = new Terminator(); frame.addWindowListener(listener); Ka de zdarzenie okna wygenerowane przez ramk jest przekazywane do obiektu listener za pomoc wywoáania jednej z jego siedmiu metod (zobacz rysunek 8.5). Sze ü z nich nie robi nic, a metoda windowClosing wywoáuje metod System.exit(0), zamykaj c tym samym aplikacj . Je li w nazwie metody rozszerzanej klasy adaptacyjnej znajdzie siö bäñd, kompi- lator go nie wykryje. Je li na przykäad w klasie rozszerzajñcej WindowAdapter zo- stanie zdefiniowana metoda windowIsClosing, nowa klasa bödzie zawieraäa osiem me- tod, a metoda windowClosing nic nie bödzie robiäa. Utworzenie klasy rozszerzaj cej klas adaptacyjn WindowAdapter jest krokiem naprzód, ale mo na posun ü si jeszcze dalej. Nie ma potrzeby nadawaü obiektowi listener nazwy. Wystarczy napisaü: frame.addWindowListener(new Terminator()); Ale czemu poprzestawaü na tym? Klasa nasáuchuj ca mo e byü anonimow klas we- wn trzn ramki.
    • 372 Java. Podstawy Rysunek 8.5. Obiekt nasäuchujñcy zdarzeþ dotyczñcych okna frame.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { if (u ytkownik potwierdza) System.exit(0); } }); Powy szy fragment programu ma nast puj ce dziaáanie: Q Definiuje klas bez nazwy, rozszerzaj c klas WindowAdapter. Q Do utworzonej anonimowej klasy dodaje metod windowClosing (podobnie jak wcze niej, metoda ta zamyka program). Q Dziedziczy sze ü pozostaáych nicnierobi cych metod po klasie WindowAdapter. Q Tworzy obiekt tej nowej klasy — obiekt równie nie ma nazwy. Q Przekazuje niniejszy obiekt do metody addWindowListener. Powtarzamy jeszcze raz, e do skáadni wewn trznych klas anonimowych trzeba si przy- zwyczaiü. Dzi ki nim mo na pisaü tak zwi záy kod, jak to tylko mo liwe.
    • RozdziaÄ 8. Q ObsÄuga zdarzeÆ 373 java.awt.event.WindowListener 1.1 Q void windowOpened(WindowEvent e) Jest wywoáywana po otwarciu okna. Q void windowClosing(WindowEvent e) Jest wywoáywana, kiedy u ytkownik wyda polecenie mened era okien, aby zamkn ü okno. Okno zostanie zamkni te tylko wtedy, gdy zostanie wywoáana jego metoda hide lub dispose. Q void windowClosed(WindowEvent e) Jest wywoáywana po zamkni ciu okna. Q void windowIconified(WindowEvent e) Jest wywoáywana po zminimalizowaniu okna. Q void windowDeiconified(WindowEvent e) Jest wywoáywana po przywróceniu okna. Q void windowActivated(WindowEvent e) Jest wywoáywana po uaktywnieniu okna. Aktywna mo e byü tylko ramka lub okno dialogowe. Z reguáy mened er okien zaznacza w jaki sposób aktywne okno — np. pod wietlaj c pasek tytuáu. Q void WindowDeactivated(WindowEvent e) Jest wywoáywana po dezaktywowaniu okna. java.awt.event.WindowStateListener 1.4 Q void windowStateChanged(WindowEvent event) Jest wywoáywana po zmaksymalizowaniu, zminimalizowaniu lub przywróceniu do normalnego rozmiaru okna. java.awt.event.WindowEvent 1.1 Q int getNewState() 1.4 Q int getOldState() 1.4 Zwraca nowy i stary stan okna w zdarzeniu zmiany stanu okna. Zwracana liczba caákowita jest jedn z nast puj cych warto ci: Frame.NORMAL Frame.ICONIFIED Frame.MAXIMIZED_HORIZ Frame.MAXIMIZED_VERT Frame.MAXIMIZED_BOTH
    • 374 Java. Podstawy Akcje Cz sto jedn opcj mo na wybraü na kilka ró nych sposobów. U ytkownik mo e wybraü odpowiedni funkcj w menu, nacisn ü okre lony klawisz lub przycisk na pasku narz dzi. Zaprogramowanie takiej funkcjonalno ci w modelu zdarze AWT jest proste — nale y wszystkie zdarzenia zwi zaü z tym samym obiektem nasáuchuj cym. Wyobra my sobie, e blueAction jest obiektem nasáuchuj cym akcji, którego metoda actionPerformed zmienia ko- lor táa na niebieski. Jeden obiekt mo na zwi zaü jako sáuchacza z kilkoma ródáami zdarze : Q przyciskiem paska narz dzi z etykiet Niebieski; Q elementem menu z etykiet Niebieski; Q skrótem klawiszowym Ctrl+N. Dzi ki temu zmiana koloru b dzie wykonywana zawsze w taki sam sposób, bez znaczenia, czy wywoáa j klikni cie przycisku, wybór elementu menu, czy naci ni cie klawisza. W pakiecie Swing dost pna jest niezwykle przydatna struktura opakowuj ca polecenia i wi - ca je z ró nymi ródáami zdarze — interfejs Action. Akcja to obiekt, który opakowuje: Q opis polecenia (áa cuch tekstowy i opcjonalna ikona), Q parametry niezb dne do wykonania polecenia (w naszym przypadku wymagany kolor). Interfejs Action zawiera nast puj ce metody: void actionPerformed(ActionEvent event) void setEnabled(boolean b) boolean isEnabled() void putValue(String key, Object value) Object getValue(String key) void addPropertyChangeListener(PropertyChangeListener listener) void removePropertyChangeListener(PropertyChangeListener listener) Pierwsza z tych metod jest ju nam znana z interfejsu ActionListener. Nale y dodaü, e inter- fejs Action rozszerza interfejs ActionListener. W zwi zku z tym wsz dzie, gdzie powinien znale ü si obiekt ActionListener, mo na u yü obiektu Action. Dwie kolejne metody wá czaj i wyá czaj akcj oraz sprawdzaj , czy akcja jest aktualnie wá czona. Kiedy akcja jest zwi zana z menu lub paskiem narz dzi i jest wyá czona, odpo- wiadaj ca jej opcja ma kolor szary. Metody putValue i getValue zapisuj i pobieraj pary nazwa – warto ü z obiektu akcji. Nazwy akcji i ikony s zapisywane w obiektach akcji za pomoc dwóch predefiniowanych áa cu- chów: Action.NAME i Action.SMALL_ICON: action.putValue(Action.NAME, "Niebieski"); action.putValue(Action.SMALL_ICON, new ImageIcon("blue-ball.gif")); Tabela 8.1 przedstawia zestawienie wszystkich predefiniowanych nazw tablicowych akcji.
    • RozdziaÄ 8. Q ObsÄuga zdarzeÆ 375 Tabela 8.1. Predefiniowane staäe interfejsu Action Nazwa WartoÊÀ NAME Nazwa akcji — wy wietlana na przyciskach i elementach menu. SMALL_ICON Maáa ikona — mo e byü wy wietlana na przyciskach, pasku narz dzi lub elementach menu. SHORT_DESCRIPTION Krótki opis ikony — wy wietlany w etykiecie narz dzia. LONG_DESCRIPTION Dáugi opis ikony — do u ytku w pomocy internetowej. aden komponent Swinga nie u ywa tej warto ci. MNEMONIC_KEY Skrót akcji — wy wietlany na elementach menu (zobacz rozdziaá 9.). ACCELERATOR_KEY Skrót klawiaturowy. aden komponent Swinga nie u ywa tej warto ci. ACTION_COMMAND_KEY U ywana w przestarzaáej ju metodzie registerKeyboardAction. DEFAULT Wáasno ü pasuj ca do wszystkiego. aden komponent Swinga nie u ywa tej warto ci. Je li obiekt akcji jest dodawany do menu lub paska narz dzi, jego nazwa i ikona s auto- matycznie pobierane i wy wietlane w menu lub na pasku narz dzi. Warto ü wáasno ci SHORT_DESCRIPTION zamienia si w dymek opisuj cy narz dzie. Pozostaáe dwie metody interfejsu Action umo liwiaj powiadamianie innych obiektów, zwáasz- cza menu i pasków narz dzi, które s ródáem akcji, o zmianach wáasno ci obiektu akcji. Je li na przykáad menu jest dodawane jako obiekt nasáuchuj cy zmian wáasno ci obiektu akcji i obiekt ten zostanie nast pnie wyá czony, menu zostanie wywoáane, a nazwa akcji b dzie szara. Obiekty nasáuchu zmian wáasno ci s ogóln konstrukcj stanowi c cz ü modelu komponentów JavaBean. Wi cej informacji na temat Beanów i ich wáasno ci znajduje si w drugim tomie. Nie nale y zapominaü, e Action to interfejs, a nie klasa. Ka da klasa implementuj ca go musi definiowaü wszystkie siedem metod, które opisali my. Na szcz cie jaki dobry czáowiek napisaá klas o nazwie AbstractAction, która implementuje wszystkie niniejsze metody z wyj tkiem actionPerformed. Klasa ta zajmuje si zapisywaniem par nazwa – warto ü i zarz dzaniem obiektami nasáuchuj cymi zmian wáasno ci. Wystarczy rozszerzyü klas AbstractAction i zdefiniowaü metod actionPerformed. Utworzymy obiekt wykonuj cy polecenia zmiany koloru. Zapiszemy nazw polecenia, iko- n i dany kolor. Kolor zapiszemy w tablicy par nazwa – warto ü dostarczanej przez klas AbstractAction. Poni ej znajduje si kod ródáowy klasy ColorAction. Konstruktor ustawia pary nazwa – warto ü, a metoda actionPerformed wykonuje akcj zmiany koloru. public class ColorAction extends AbstractAction { public ColorAction(String name, Icon icon, Color c) { putValue(Action.NAME, name); putValue(Action.SMALL_ICON, icon); putValue("color", c); putValue(Action.SHORT_DESCRIPTION, "Ustaw kolor panelu na " + name.toLowerCase()); }
    • 376 Java. Podstawy public void actionPerformed(ActionEvent event) { Color c = (Color) getValue("color"); buttonPanel.setBackground(c); } } Nasz przykáadowy program tworzy trzy obiekty niniejszej klasy, np.: Action blueAction = new ColorAction("Niebieski", new ImageIcon("blue-ball.gif"), ´Color.BLUE); Teraz konieczne jest zwi zanie akcji z przyciskiem. Jest to áatwe, poniewa mo emy u yü konstruktora JButton, który przyjmuje obiekt typu Action. JButton blueButton = new JButton(blueAction); Konstruktor odczytuje nazw i ikon z akcji, ustawia krótki opis jako etykiet oraz ustawia akcj jako sáuchacza. Ikony i etykiet przedstawia rysunek 8.6. Rysunek 8.6. Przyciski zawierajñ ikony z obiektów akcji W kolejnym rozdziale wyka emy, e tak samo áatwe jest dodawanie tej samej akcji do menu. Na koniec przypiszemy obiekty akcji do klawiszy, dzi ki czemu akcje te b d wykonywane, kiedy u ytkownik wpisze polecenia z klawiatury. Kojarzenie akcji z klawiszami nale y za- cz ü od wygenerowania obiektu klasy KeyStroke. Klasa ta opakowuje opis klawisza. Do utworzenia obiektu typu KeyStroke nie u ywa si konstruktora, ale statycznej metody getKeyStroke klasy KeyStroke. KeyStroke ctrlBKey = KeyStroke.getKeyStroke("ctrl N"); Do zrozumienia nast pnego etapu potrzebna jest znajomo ü poj cia aktywno ci komponentu (ang. keyboard focus). Interfejs u ytkownika mo e skáadaü si z wielu przycisków, menu, pasków przewijania i innych komponentów. Kiedy zostanie naci ni ty klawisz, zdarzenie to zostaje wysáane do aktywnego komponentu. Komponent ten jest z reguáy (choü nie zawsze) w jaki sposób wizualnie wyró niony. Na przykáad w stylu Javy tekst na aktywnym przycisku ma cienk obwódk . Fokus (aktywno ü komponentu) mo na przenosiü na ró ne kompo- nenty za pomoc klawisza Tab. Naci ni cie klawisza spacji powoduje klikni cie aktywnego przycisku. Inne klawisze wywoáuj inne dziaáania. Na przykáad klawisze strzaáek mog ste- rowaü paskiem przewijania. Jednak my nie chcemy wysyáaü zdarzenia naci ni cia klawisza do aktywnego komponentu. W przeciwnym razie ka dy przycisk musiaáby znaü procedur obsáugi kombinacji klawiszy Ctrl+Y, Ctrl+B i Ctrl+R.
    • RozdziaÄ 8. Q ObsÄuga zdarzeÆ 377 Jest to bardzo powszechny problem. Jednak projektanci biblioteki Swing znale li dla niego proste rozwi zanie. Ka dy JComponent posiada trzy mapy wej cia (ang. input maps), z których ka da odwzorowuje obiekty KeyStroke na zwi zane z nimi akcje. Mapy te odpowiadaj trzem ró nym sytuacjom (zobacz tabela 8.2). Tabela 8.2. Mapy klawiaturowe Znacznik WywoÄuje dziaÄanie, gdy WHEN_FOCUSED komponent jest aktywny; WHEN_ANCESTOR_OF_FOCUSED_COMPONENT komponent zawiera komponent aktywny; WHEN_IN_FOCUSED_WINDOW komponent znajduje si w tym samym oknie co komponent aktywny. Niniejsze mapy s sprawdzane w nast puj cej kolejno ci w wyniku naci ni cia klawisza: 1. Sprawdzenie mapy WHEN_FOCUSED aktywnego komponentu. Je li dany skrót klawiaturowy istnieje, nast puje wykonanie powi zanego z nim dziaáania. Je li dziaáanie zostaje wykonane, nast puje zatrzymanie sprawdzania warunków. 2. Nast puje sprawdzenie map WHEN_ANCESTOR_OF_FOCUSED_COMPONENT aktywnego komponentu, a nast pnie jego komponentów nadrz dnych. Gdy zostanie znaleziona mapa z danym skrótem klawiaturowym, nast puje wykonanie dziaáania. Je li dziaáanie zostaje wykonane, nast puje zatrzymanie sprawdzania warunków. 3. Odszukanie wszystkich widocznych i wá czonych komponentów w aktywnym oknie, w których mapie WHEN_IN_FOCUSED_WINDOW znajduje si dany skrót klawiaturowy. Umo liwienie tym komponentom (w kolejno ci zgodnej z rejestracj zdarze naci ni cia klawisza) wykonania odpowiednich dziaáa . Po wykonaniu pierwszego dziaáania nast puje zatrzymanie przetwarzania. Ta cz ü procesu mo e byü ródáem problemów, je li dany skrót klawiaturowy pojawia si w wi cej ni jednej mapie WHEN_IN_FOCUSED_WINDOW. Map wej cia komponentu tworzy si za pomoc metody getInputMap. Na przykáad: InputMap imap = panel.getInputMap(JComponent.WHEN_FOCUSED); Warunek WHEN_FOCUSED powoduje, e ta mapa b dzie sprawdzana, gdy komponent jest ak- tywny. Nam potrzebna jest inna mapa. Aktywny jest jeden z przycisków, nie panel. Do wsta- wienia skrótów klawiszy zmieniaj cych kolor nadaje si jedna z pozostaáych dwóch map. W naszym przykáadowym programie u yjemy mapy WHEN_ANCESTOR_OF_FOCUSED_COMPONENT. Klasa InputMap nie odwzorowuje bezpo rednio obiektów KeyStroke w postaci obiektów Action. W zamian odwzorowuje w postaci dowolnych obiektów, a druga mapa, zaimple- mentowana w klasie ActionMap, mapuje obiekty na akcje. Dzi ki temu áatwiej jest wspóádzie- liü te same akcje przez skróty klawiaturowe pochodz ce z ró nych map wej cia. A zatem ka dy komponent posiada trzy mapy wej cia i jedn map akcji (ang. action map). Aby je powi zaü, trzeba wymy liü nazwy dla akcji. Klawisz mo na powi zaü z akcj w na- st puj cy sposób:
    • 378 Java. Podstawy imap.put(KeyStroke.getKeyStroke("ctrl Z"), "panel.yellow"); ActionMap amap = panel.getActionMap(); amap.put("panel.yellow", yellowAction); W przypadku akcji niewykonuj cej adnych dziaáa zwyczajowo stosuje si áa cuch none. W ten sposób mo na áatwo dezaktywowaü klawisz: imap.put(KeyStroke.getKeyStroke("ctrl C"), "none"); Dokumentacja JDK zaleca stosowanie jako klucza akcji jej nazwy. Naszym zdaniem nie jest to dobre rozwiñzanie. Nazwa akcji jest wy wietlana na przyciskach i ele- mentach menu, w zwiñzku z czym mo e siö zmieniaè w zale no ci od kaprysu projek- tanta interfejsu oraz mo e byè przetäumaczona na wiele jözyków. Takie niestaäe äaþcu- chy nie sñ dobrym wyborem w przypadku klawiszy wyszukiwania. Zalecamy wymy lenie nazw akcji niezale nych od wy wietlanych nazw. Poni ej znajduje si zestawienie dziaáa , które trzeba wykonaü, aby wywoáaü to samo dziaáa- nie w odpowiedzi na zdarzenie naci ni cia przycisku, wyboru elementu z menu lub naci ni - cia klawisza: 1. Utwórz podklas klasy AbstractAction. Mo na u yü tej samej klasy dla wielu spokrewnionych akcji. 2. Utwórz obiekt powy szej klasy akcji. 3. Utwórz przycisk lub element menu z obiektu powy szej klasy akcji. Konstruktor odczyta etykiet i ikon z tego obiektu. 4. W przypadku akcji uruchamianych przez naci ni cie klawisza konieczne jest wykonanie dodatkowych czynno ci. Najpierw nale y zlokalizowaü komponent najwy szego poziomu w oknie, np. panel zawieraj cy wszystkie pozostaáe elementy. 5. Pobierz map WHEN_ANCESTOR_OF_FOCUSED_COMPONENT komponentu najwy szego poziomu. Utwórz obiekt klasy KeyStroke reprezentuj cy odpowiedni skrót klawiaturowy. Utwórz obiekt b d cy kluczem dziaáania, np. áa cuch opisuj cy akcj . Wstaw niniejsz par danych (klawisz, klucz dziaáania) do mapy wej cia. 6. Pobierz map akcji komponentu najwy szego poziomu. Dodaj par klucz akcji – obiekt akcji do tej mapy. Listing 8.3 przedstawia kompletny kod programu mapuj cego przyciski i klawisze na obiekty akcji. Mo na go wypróbowaü — klikni cie jednego z przycisków lub naci ni cie kombinacji klawiszy Ctrl+Z, Ctrl+N lub Ctrl+C spowoduje zmian koloru panelu. Listing 8.3. ActionTest.java import java.awt.*; import java.awt.event.*; import javax.swing.*; /** * @version 1.33 2007-06-12 * @author Cay Horstmann */
    • RozdziaÄ 8. Q ObsÄuga zdarzeÆ 379 public class ActionTest { public static void main(String[] args) { EventQueue.invokeLater(new Runnable() { public void run() { ActionFrame frame = new ActionFrame(); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); } }); } } /** * Ramka z panelem, który demonstruje akcje zmiany koloru. */ class ActionFrame extends JFrame { public ActionFrame() { setTitle("ActionTest"); setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT); buttonPanel = new JPanel(); // Definicje akcji. Action yellowAction = new ColorAction(" ó ty", new ImageIcon("yellow-ball.gif"), Color.YELLOW); Action blueAction = new ColorAction("Niebieski", new ImageIcon("blue-ball.gif"), ´Color.BLUE); Action redAction = new ColorAction("Czerwony", new ImageIcon("red-ball.gif"), ´Color.RED); // Dodanie przycisków dla akcji. buttonPanel.add(new JButton(yellowAction)); buttonPanel.add(new JButton(blueAction)); buttonPanel.add(new JButton(redAction)); // Dodanie panelu do ramki. add(buttonPanel); // Powi zanie klawiszy Z, N i C z nazwami. InputMap imap = buttonPanel.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_ ´COMPONENT); imap.put(KeyStroke.getKeyStroke("ctrl Z"), "panel.yellow"); imap.put(KeyStroke.getKeyStroke("ctrl N"), "panel.blue"); imap.put(KeyStroke.getKeyStroke("ctrl C"), "panel.red"); // Powi zanie nazw z akcjami. ActionMap amap = buttonPanel.getActionMap(); amap.put("panel.yellow", yellowAction); amap.put("panel.blue", blueAction); amap.put("panel.red", redAction); }
    • 380 Java. Podstawy public class ColorAction extends AbstractAction { /** * Tworzy akcj zmiany koloru. * @param name nazwa, która pojawi si na przycisku * @param icon ikona, która pojawi si na przycisku * @param c kolor táa */ public ColorAction(String name, Icon icon, Color c) { putValue(Action.NAME, name); putValue(Action.SMALL_ICON, icon); putValue(Action.SHORT_DESCRIPTION, "Ustaw kolor panelu na " + name. ´toLowerCase()); putValue("color", c); } public void actionPerformed(ActionEvent event) { Color c = (Color) getValue("color"); buttonPanel.setBackground(c); } } private JPanel buttonPanel; public static final int DEFAULT_WIDTH = 300; public static final int DEFAULT_HEIGHT = 200; } javax.swing.Action 1.2 Q boolean isEnabled() Q void setEnabled(boolean b) Pobiera lub ustawia wáasno ü enabled akcji. Q void putValue(String key, Object value) Wstawia par nazwa – warto ü do obiektu akcji. Parametry: key Nazwa wáasno ci, która ma zostaü zapisana z obiektem akcji. Mo e to byü dowolny áa cuch, ale jest kilka nazw o z góry zdefiniowanym znaczeniu — zobacz tabel 8.1 na stronie 375. value Obiekt powi zany z nazw . Q Object getValue(String key) Zwraca warto ü z zapisanej pary nazwa – warto ü.
    • RozdziaÄ 8. Q ObsÄuga zdarzeÆ 381 javax.swing.KeyStroke 1.2 Q static KeyStroke getKeyStroke(String description) Tworzy skrót klawiaturowy z czytelnego dla czáowieka opisu (ci gu áa cuchów rozdzielonych spacjami). Opis zaczyna si od zera lub wi kszej liczby modyfikatorów shift control ctrl meta alt altGraph, a ko czy si áa cuchem typed i áa cuchem skáadaj cym si z jednego znaku (na przykáad typed a) lub opcjonalnym specyfikatorem zdarzenia (pressed — domy lny lub released) i kodem klawisza. Kod klawisza, je li ma przedrostek VK_, powinien odpowiadaü staáej KeyEvent, na przykáad INSERT odpowiada KeyEvent.VK_INSERT. javax.swing.JComponent 1.2 Q ActionMap getActionMap() 1.3 Zwraca map wi c klucze mapy akcji (które mog byü dowolnymi obiektami) z obiektami klasy Action. Q InputMap getInputMap(int flag) 1.3 Pobiera map wej cia, która odwzorowuje klawisze w postaci kluczy mapy akcji. Parametry: flag Warunek okre laj cy, kiedy element aktywny ma wywoáaü akcj — jedna z warto ci z tabeli 8.2 na stronie 377. Zdarzenia generowane przez mysz Takie zdarzenia jak klikni cie przycisku lub elementu w menu za pomoc myszy nie wyma- gaj pisania procedur obsáugi. Niniejsze zdarzenia s obsáugiwane automatycznie przez ró ne elementy interfejsu u ytkownika. Aby jednak umo liwiü rysowanie za pomoc myszy, konieczne jest przechwycenie zdarze ruchu, klikni cia i przeci gania myszy. W niniejszym podrozdziale prezentujemy prosty edytor grafiki pozwalaj cy umieszczaü, prze- suwaü i usuwaü kwadraty z obszaru roboczego (zobacz rysunek 8.7). Rysunek 8.7. Program obsäugujñcy zdarzenia myszy
    • 382 Java. Podstawy Kiedy u ytkownik naci nie przycisk myszy, wywoáywane s trzy metody nasáuchuj ce: mousePressed po naci ni ciu przycisku, mouseReleased po zwolnieniu przycisku myszy i mouseClicked. Je li w sferze zainteresowa le wyá cznie peáne klikni cia, pierwsze dwie z wymienionych metod mo na pomin ü. Wywoáuj c metody getX i getY na rzecz obiektu klasy MouseEvent, mo na sprawdziü wspóárz dne x i y wska nika myszy w chwili klik- ni cia. Do rozró nienia pojedynczych, podwójnych i potrójnych (!) klikni ü sáu y metoda getClickCount. Niektórzy projektanci interfejsów tworz kombinacje klawiszy poá czone z klikni ciami myszk , np. Ctrl+Shift+klikni cie. Naszym zdaniem jest to post powanie niegodne na la- dowania. Osoby, które nie zgadzaj si z nasz opini , mo e przekonaü fakt, e sprawdzanie przycisków myszy i klawiszy specjalnych jest niezwykle zagmatwanym zadaniem — nieba- wem si o tym przekonamy. Aby sprawdziü, które modyfikatory zostaáy ustawione, nale y u yü maski bitowej. W ory- ginalnym API dwie maski przycisków s równowa ne z maskami klawiszy specjalnych, mianowicie: BUTTON2_MASK == ALT_MASK BUTTON3_MASK == META_MASK Zrobiono tak, aby u ytkownicy posiadaj cy myszk z jednym przyciskiem mogli na lado- waü pozostaáe przyciski za pomoc klawiszy specjalnych (ang. modifier keys). Od Java SE 1.4 zaproponowano jednak inn metod . Od tej pory istniej nast puj ce maski: BUTTON1_DOWN_MASK BUTTON2_DOWN_MASK BUTTON3_DOWN_MASK SHIFT_DOWN_MASK CTRL_DOWN_MASK ALT_DOWN_MASK ALT_GRAPH_DOWN_MASK META_DOWN_MASK Metoda getModifiersEx zwraca dokáadne informacje o przyciskach myszy i klawiszach spe- cjalnych u ytych w zdarzeniu myszy. Pami tajmy, e maska BUTTON3_DOWN_MASK w systemie Windows sprawdza prawy (nie gáówny) przycisk myszy. Na przykáad poni szy fragment programu sprawdza, czy prawy przycisk myszy jest wci ni ty: if ((event.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) != 0) . . . // procedury obsáugi zdarzenia klikni cia prawym przyciskiem myszy W przykáadowym programie definiujemy zarówno metod mousePressed, jak i mouseClicked. Je li u ytkownik kliknie piksel nieznajduj cy si w obr bie adnego z narysowanych kwa- dratów, zostanie dodany nowy kwadrat. Dziaáanie to zostaáo zaimplementowane w metodzie mousePressed, a wi c kwadrat pojawia si natychmiast po klikni ciu, przed zwolnieniem przycisku myszy. Dwukrotne klikni cie przyciskiem myszy w obr bie narysowanego kwa- dratu powoduje jego usuni cie. Implementacja tej funkcji zostaáa umieszczona w metodzie mouseClicked, poniewa konieczne jest sprawdzenie liczby klikni ü:
    • RozdziaÄ 8. Q ObsÄuga zdarzeÆ 383 public void mousePressed(MouseEvent event) { current = find(event.getPoint()); if (current == null) // nie w obr bie adnego kwadratu add(event.getPoint()); } public void mouseClicked(MouseEvent event) { current = find(event.getPoint()); if (current != null && event.getClickCount() >= 2) remove(current); } Kiedy kursor myszy przesuwa si nad oknem, odbiera ono staáy strumie zdarze ruchu myszy. Zauwa my, e s osobne interfejsy MouseListener i MouseMotionListener. Wyró nio- no je z ch ci zwi kszenia efektywno ci. Kiedy u ytkownik przesuwa mysz, powstaje caáa masa zdarze dotycz cych tej czynno ci. Obiekt nasáuchuj cy, który oczekuje na klikni cia, nie jest zajmowany przez nieinteresuj ce go zdarzenia ruchu. Nasz testowy program przechwytuje zdarzenia ruchu i w odpowiedzi na nie zmienia wygl d kursora (na krzy yk). Odpowiedzialna jest za to metoda getPredefinedCursor z klasy Cursor. Tabela 8.3 przedstawia staáe podawane jako argument wspomnianej funkcji oraz reprezento- wane przez nie kursory w systemie Windows. Tabela 8.3. Przykäadowe kursory Ikona StaÄa Ikona StaÄa DEFAULT_CURSOR NE_RESIZE_CURSOR CROSSHAIR_CURSOR E_RESIZE_CURSOR HAND_CURSOR SE_RESIZE_CURSOR MOVE_CURSOR S_RESIZE_CURSOR TEXT_CURSOR SW_RESIZE_CURSOR WAIT_CURSOR W_RESIZE_CURSOR N_RESIZE_CURSOR NW_RESIZE_CURSOR Poni ej znajduje si kod ródáowy metody mouseMoved z klasy MouseMotionListener zdefi- niowanej w naszym przykáadowym programie: public void mouseMoved(MouseEvent event) { if (find(event.getPoint()) == null) setCursor(Cursor.getDefaultCursor()); else setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR)); }
    • 384 Java. Podstawy Mo na zdefiniowaè wäasne typy kursorów. Säu y do tego metoda createCustom- ´Cursor z klasy Toolkit: Toolkit tk = Toolkit.getDefaultToolkit(); Image img = tk.getImage("dynamite.gif"); Cursor dynamiteCursor = tk.createCustomCursor(img, new Point(10, 10), "dynamite ´stick"); Pierwszy argument niniejszej metody okre la plik graficzny przedstawiajñcy kursor. Drugi wyznacza przesuniöcie punktu aktywnego kursora. Trzeci jest äaþcuchem opisujñcym kursor. ãaþcuch ten mo e säu yè zwiökszeniu dostöpno ci. Na przykäad program czytajñcy z ekranu u ywany przez osobö niedowidzñcñ mo e przeczytaè opis takiego kursora. Je li w czasie przesuwania myszy u ytkownik kliknie jej przycisk, generowane s wywoáania metody mouseDragged zamiast mouseMoved. Nasz przykáadowy program zezwala na przeci ga- nie kwadratów pod kursorem. Efekt ten uzyskali my, aktualizuj c poáo enie przeci ganego kwadratu, tak aby jego rodek znajdowaá si w tym samym miejscu co punkt centralny myszki. Nast pnie ponownie rysujemy obszar roboczy, aby ukazaü nowe poáo enie kursora myszy. public void mouseDragged(MouseEvent event) { if (current != null) { int x = event.getX(); int y = event.getY(); current.setFrame(x - SIDELENGTH / 2, y - SIDELENGTH / 2, SIDELENGTH, SIDELENGTH); repaint(); } Metoda mouseMoved jest wywoäywana tylko wtedy, gdy kursor znajduje siö w ob- röbie komponentu. Natomiast metoda mouseDragged jest wywoäywana nawet wtedy, gdy kursor opu ci komponent. Istniej jeszcze dwie inne metody obsáuguj ce zdarzenia myszy: mouseEntered i mouseExited. S one wywoáywane, gdy kursor myszy wchodzi do komponentu lub go opuszcza. Na zako czenie wyja nimy sposób nasáuchiwania zdarze generowanych przez mysz. Klik- ni cia przyciskiem myszy s raportowane przez metod mouseClicked nale c do interfejsu MouseListener. Poniewa wiele aplikacji korzysta wyá cznie z klikni ü myszk i wyst puj one bardzo cz sto, zdarzenia ruchu myszy i przeci gania zostaáy zdefiniowane w osobnym interfejsie o nazwie MouseMotionListener. W naszym programie interesuj nas oba rodzaje zdarze generowanych przez mysz. Zdefi- niowali my dwie klasy wewn trzne o nazwach MouseHandler i MouseMotionHandler. Pierwsza z nich jest podklas klasy MouseAdapter, poniewa definiuje tylko dwie z pi ciu metod interfej- su MouseListener. Klasa MouseMotionHandler implementuje interfejs MouseMotionListener, co znaczy, e zawiera definicje obu jego metod. Listing 8.4 przedstawia kod ródáowy oma- wianego programu.
    • RozdziaÄ 8. Q ObsÄuga zdarzeÆ 385 Listing 8.4. MouseTest.java import java.awt.*; import java.awt.event.*; import java.util.*; import java.awt.geom.*; import javax.swing.*; /** * @version 1.32 2007-06-12 * @author Cay Horstmann */ public class MouseTest { public static void main(String[] args) { EventQueue.invokeLater(new Runnable() { public void run() { MouseFrame frame = new MouseFrame(); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); } }); } } /** * Ramka zawieraj ca panel testuj cy dziaáania myszy. */ class MouseFrame extends JFrame { public MouseFrame() { setTitle("MouseTest"); setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT); // Dodanie komponentu do ramki. MouseComponent component = new MouseComponent(); add(component); } public static final int DEFAULT_WIDTH = 300; public static final int DEFAULT_HEIGHT = 200; } /** * Komponent z dziaáaniami myszy, do którego mo na dodawaü (lub z którego mo na usuwaü) kwadraty. */ class MouseComponent extends JComponent { public MouseComponent() { squares = new ArrayList<Rectangle2D>(); current = null;
    • 386 Java. Podstawy addMouseListener(new MouseHandler()); addMouseMotionListener(new MouseMotionHandler()); } public void paintComponent(Graphics g) { Graphics2D g2 = (Graphics2D) g; // Rysowanie wszystkich kwadratów. for (Rectangle2D r : squares) g2.draw(r); } /** * Znajduje pierwszy kwadrat zawieraj cy punkt. * @param p punkt * @return pierwszy kwadrat zawieraj cy punkt p */ public Rectangle2D find(Point2D p) { for (Rectangle2D r : squares) { if (r.contains(p)) return r; } return null; } /** * Dodaje kwadrat do zbioru. * @param p rodek kwadratu */ public void add(Point2D p) { double x = p.getX(); double y = p.getY(); current = new Rectangle2D.Double(x - SIDELENGTH / 2, y - SIDELENGTH / 2, SIDELENGTH, SIDELENGTH); squares.add(current); repaint(); } /** * Usuwa kwadrat ze zbioru. * @param s kwadrat, który ma byü usuni ty */ public void remove(Rectangle2D s) { if (s == null) return; if (s == current) current = null; squares.remove(s); repaint(); } private static final int SIDELENGTH = 10; private ArrayList<Rectangle2D> squares; private Rectangle2D current;
    • RozdziaÄ 8. Q ObsÄuga zdarzeÆ 387 // Kwadrat zawieraj cy kursor myszy. private class MouseHandler extends MouseAdapter { public void mousePressed(MouseEvent event) { // Dodanie nowego kwadratu, je li kursor nie jest wewn trz innego kwadratu. current = find(event.getPoint()); if (current == null) add(event.getPoint()); } public void mouseClicked(MouseEvent event) { // Usuni cie kwadratu w wyniku jego dwukrotnego klikni cia. current = find(event.getPoint()); if (current != null && event.getClickCount() >= 2) remove(current); } } private class MouseMotionHandler implements MouseMotionListener { public void mouseMoved(MouseEvent event) { // Ustawienie kursora na krzy yk, je li znajduje si wewn trz // kwadratu. if (find(event.getPoint()) == null) setCursor(Cursor.getDefaultCursor()); else setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR)); } public void mouseDragged(MouseEvent event) { if (current != null) { int x = event.getX(); int y = event.getY(); // Przeci gni cie aktualnego kwadratu w celu wycentrowania go w punkcie (x, y). current.setFrame(x - SIDELENGTH / 2, y - SIDELENGTH / 2, SIDELENGTH, ´SIDELENGTH); repaint(); } } } } java.awt.event.MouseEvent 1.1 Q int getX() Q int getY() Q Point getPoint() Zwraca wspóárz dne x (pozioma) i y (pionowa) lub punkt, w którym miaáo miejsce zdarzenie, mierz c od lewego górnego rogu komponentu b d cego ródáem zdarzenia.
    • 388 Java. Podstawy Q int getClickCount() Zwraca liczb kolejnych klikni ü przyciskiem myszy zwi zanych z danym zdarzeniem (odst p czasu oddzielaj cy zdarzenia okre lane jako kolejne zale y od systemu). java.awt.event.InputEvent 1.1 Q int getModifiersEx() 1.4 Zwraca rozszerzone modyfikatory zdarzenia. Do sprawdzania zwróconych warto ci sáu nast puj ce maski: BUTTON1_DOWN_MASK BUTTON2_DOWN_MASK BUTTON3_DOWN_MASK SHIFT_DOWN_MASK CTRL_DOWN_MASK ALT_DOWN_MASK ALT_GRAPH_DOWN_MASK META_DOWN_MASK Q static String getModifiersExText(int modifiers) 1.4 Zwraca áa cuch typu Shift+Button1 opisuj cy rozszerzone modyfikatory w danym zbiorze znaczników. java.awt.Toolkit 1.0 Q public Cursor createCustomCursor(Image image, Point hotSpot, String name)1.2 Tworzy nowy obiekt niestandardowego kursora. Parametry: image Obraz reprezentuj cy kursor hotSpot Punkt centralny kursora (na przykáad ko cówka strzaáki lub rodek krzy yka) name Opis kursora wspomagaj cy dost pno ü w specjalnych rodowiskach java.awt.Component 1.0 Q public void setCursor(Cursor cursor) 1.1 Ustawia obraz kursora na okre lony kursor. Hierarchia zdarzeÆ w bibliotece AWT Maj c ju pewne rozeznanie w temacie obsáugi zdarze , na zako czenie niniejszego rozdziaáu zrobimy krótki przegl d architektury obsáugi zdarze biblioteki AWT.
    • RozdziaÄ 8. Q ObsÄuga zdarzeÆ 389 Jak wspominali my wcze niej, zdarzenia w Javie s obsáugiwane w metodologii obiektowej, a wszystkie zdarzenia pochodz od klasy EventObject z pakietu java.util (nazw wspólnej nadklasy nie jest Event, poniewa tak nazw nosi klasa zdarze w starym modelu zdarze — mimo e model ten jest obecnie odradzany, jego klasy nadal wchodz w skáad biblio- teki Javy). Klasa EventObject posiada podklas AWTEvent b d c nadklas wszystkich klas zdarzenio- wych AWT. Rysunek 8.8 przedstawia diagram dziedziczenia zdarze AWT. Rysunek 8.8. Diagram dziedziczenia klas zdarzeniowych AWT Niektóre komponenty Swing generuj obiekty zdarzeniowe jeszcze innych typów zdarze . Rozszerzaj one bezpo rednio klas EventObject, a nie AWTEvent.
    • 390 Java. Podstawy Obiekty zdarzeniowe zawieraj informacje o zdarzeniach przesyáanych przez ródáo zda- rze do swoich sáuchaczy. W razie potrzeby mo na przeanalizowaü obiekty zdarzeniowe, które zostaáy przekazane do obiektów nasáuchuj cych, co zrobili my w przykáadzie z przy- ciskiem za pomoc metod getSource i getActionCommands. Niektóre klasy zdarzeniowe AWT s dla programisty Javy bezu yteczne. Na przykáad biblio- teka AWT wstawia do kolejki zdarze obiekty PaintEvent, ale obiekty te nie s dostarczane do sáuchaczy. Programi ci Javy nie nasáuchuj zdarze rysowania. Przesáaniaj oni metod paintComponent, aby móc kontrolowaü ponowne rysowanie. Ponadto AWT generuje pewne zdarzenia, które s potrzebne tylko programistom systemowym. Nie opisujemy tych specjal- nych typów zdarze . Zdarzenia semantyczne i niskiego poziomu Biblioteka AWT rozró nia zdarzenia niskiego poziomu i zdarzenia semantyczne. Zdarzenie semantyczne jest dzieáem u ytkownika ( jest to np. klikni cie przycisku). Dlatego zdarzenie ActionEvent jest zdarzeniem semantycznym. Zdarzenia niskiego poziomu to takie zdarze- nia, które umo liwiaj zaistnienie zdarze semantycznych. W przypadku klikni cia przyci- sku jest to jego naci ni cie, szereg ruchów mysz i zwolnienie (ale tylko je li zwolnienie nast pi w obr bie przycisku). Mo e to byü naci ni cie klawisza maj ce miejsce po wybra- niu przycisku przez u ytkownika za pomoc klawisza Tab i naci ni cia go za pomoc spa- cji. Podobnie semantycznym zdarzeniem jest przesuni cie paska przewijania, a ruch mysz jest zdarzeniem niskiego poziomu. Poni ej znajduje si lista najcz ciej u ywanych klas zdarze semantycznych pakietu java.awt.event: Q ActionEvent — klikni cie przycisku, wybór elementu z menu, wybór elementu listy, naci ni cie klawisza Enter w polu tekstowym. Q AdjustmentEvent — przesuni cie paska przewijania. Q ItemEvent — wybór jednego z pól do wyboru lub elementów listy. Do najcz ciej u ywanych klas zdarze niskiego poziomu zaliczaj si : Q KeyEvent — naci ni cie lub zwolnienie klawisza. Q MouseEvent — naci ni cie lub zwolnienie przycisku myszy, poruszenie lub przeci gni cie mysz . Q MouseWheelEvent — pokr cenie kóákiem myszy. Q FocusEvent — uaktywnienie lub dezaktywacja elementu. Q WindowEvent— zmiana stanu okna. Niniejszych zdarze nasáuchuj nast puj ce interfejsy: ActionListener AdjustmentListener FocusListener ItemListener
    • RozdziaÄ 8. Q ObsÄuga zdarzeÆ 391 KeyListener MouseListener MouseMotionListener MouseWheelListener WindowListener WindowFocusListener WindowStateListener Niektóre interfejsy nasáuchuj ce AWT, te zawieraj ce wi cej ni jedn metod , posiadaj od- powiadaj ce im klasy adaptacyjne, które implementuj wszystkie ich metody (pozostaáe inter- fejsy maj tylko jedn metod , a wi c utworzenie dla nich klas adaptacyjnych nie daáoby adnych korzy ci). Poni sze klasy adaptacyjne s cz sto u ywane: FocusAdapter KeyAdapter MouseAdapter MouseMotionAdapter WindowAdapter Tabela 8.4 przedstawia najwa niejsze interfejsy nasáuchowe, zdarzenia i ródáa zdarze bi- blioteki AWT. Tabela 8.4. Obsäuga zdarzeþ Parametry/ Zdarzenia Interfejs Metody metody dostÂpu generowane przez ActionListener actionPerformed ActionEvent AbstractButton getActionCommand JComboBox getModifiers JTextField Timer AdjustmentListener adjustmentValueChanged AdjustmentEvent JScrollbar getAdjustable getAdjustmentType getValue ItemListener itemStateChanged ItemEvent AbstractButton getItem JComboBox getItemSelectable getStateChange FocusListener focusGained FocusEvent Component focusLost isTemporary KeyListener keyPressed KeyEvent Component keyReleased getKeyChar keyTyped getKeyCode getKeyModifiersText getKeyText isActionText
    • 392 Java. Podstawy Tabela 8.4. Obsäuga zdarzeþ (ciñg dalszy) Parametry/ Zdarzenia Interfejs Metody metody dostÂpu generowane przez MouseListener mousePressed MouseEvent Component mouseReleased getClickCount mouseEntered getX mouseExited getY mouseClicked getPoint translatePoint MouseMotionListener mouseDragged MouseEvent Component mouseMoved MouseWheelListener MouseWheelMoved MouseWheelEvent Component getWheelRotation getScrollAmount WindowListener windowClosing WindowEvent Window windowOpened getWindow windowIconified windowDeiconified windowClosed windowActivated windowDeactivated WindowFocusListener windowGainedFocus WindowEvent Window windowLostFocus getOppositeWindow WindowStateListener windowStateChanged WindowEvent Window getOldState getNewState Pakiet javax.swing.event zawiera dodatkowe zdarzenia specyficzne dla komponentów Swinga. Niektóre z nich opisujemy w nast pnym rozdziale. Na tym zako czymy opis technik obsáugi zdarze AWT. W nast pnym rozdziale nauczymy si wykorzystywaü najpopularniejsze komponenty Swinga oraz szczegóáowo przeanalizu- jemy generowane przez nie zdarzenia.