Java. Podstawy. Wydanie VIII

935 views

Published on

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ść!

Published in: Technology, News & Politics
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
935
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
3
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Java. Podstawy. Wydanie VIII

  1. 1. 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
  2. 2. 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
  3. 3. 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
  4. 4. 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
  5. 5. 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
  6. 6. 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
  7. 7. 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
  8. 8. 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
  9. 9. 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
  10. 10. 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
  11. 11. 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.
  12. 12. 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);
  13. 13. 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.).
  14. 14. 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)
  15. 15. 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);
  16. 16. 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 {
  17. 17. 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 {
  18. 18. 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.
  19. 19. 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.
  20. 20. 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.
  21. 21. 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")
  22. 22. 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ü
  23. 23. 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); } }); } }
  24. 24. 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; }
  25. 25. 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.
  26. 26. 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) {}
  27. 27. 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.
  28. 28. 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.
  29. 29. 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
  30. 30. 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.
  31. 31. 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()); }

×