Java 2. Techniki zaawansowane

1,494 views

Published on


* Przewodnik dla doświadczonych programistów omawiający zaawansowane możliwości platformy Java dla wersji JDK 1.3 i 1.4.
* Dostarcza wielu praktycznych przykładów kodu!
* Zawiera nowe bądź zaktualizowane omówienie: języka XML, problematyki bezpieczeństwa, programowania aplikacji sieciowych, wielowątkowości, kolekcji, zdalnych obiektów, interfejsu JDBC™, architektury komponentów JavaBeans™, biblioteki Swing i wielu innych zagadnień.


Przewodnik po zaawansowanych metodach programowania w Javie dla zaawansowanych programistów.

Książka ta dostarcza doświadczonym programistom rozwiązań niezbędnych do pełnego wykorzystania możliwości Javy. To praktyczny przewodnik ułatwiający rozwiązywanie nawet najbardziej złożonych problemów programistycznych. Dodatkowo zawiera zupełnie nowy rozdział poświęcony wykorzystaniu języka XML w programach pisanych w Javie oraz zaktualizowane omówienie wielu zaawansowanych możliwości tej platformy -- od kolekcji po metody macierzyste, od bezpieczeństwa po bibliotekę Swing.

Autorzy identyfikują problemy najczęściej napotykane przez doświadczonych programistów Javy i dostarczają przemyślanych rozwiązań zilustrowanych przykładami kodu, które uczyniły z tej książki prawdziwy bestseller. Dzięki niej ujrzysz w nowym świetle zagadnienia interfejsu ODBC™, tworzenia aplikacji sieciowych, wykorzystania zdalnych obiektów i wiele innych.

Najważniejsze informacje dla programistów Java:

* Zaktualizowane omówienie wielowątkowości, kolekcji i aplikacji sieciowych.
* Zmienione przedstawienie problematyki zdalnych obiektów.
* Nowe, zaawansowane techniki wykorzystania architektury komponentów JavaBeans™.
* Zaawansowane techniki tworzenia interfejsu użytkownika wykorzystujące biblioteki Swing i AWT.

Książka będzie dla Ciebie kolejnym krokiem w poznaniu możliwości Javy. Jest rozszerzeniem i doskonałym uzupełnieniem publikacji "Java 2. Postawy".

O autorach:
CAY S. HORSTMANN wykłada informatykę na uniwersytecie stanowym w San Jose. Napisał sześć książek o C++, Javie i programowaniu zorientowanym obiektowo. Jest redaktorem naczelnym bestselerowego cyklu Core Series, wydawnictwa Prentice Hall PTR.

GARY CORNELL zrobił doktorat na uniwersytecie Brown i współpracował z IBM Watson Labs. Jest autorem lub współautorem 20 książek oraz wielu artykułów, wydrukowanych w czasopismach komputerowych. Obecnie kieruje programem Modern Visual Programming na Uniwersytecie Connecticut.

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
1,494
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
9
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Java 2. Techniki zaawansowane

  1. 1. IDZ DO PRZYK£ADOWY ROZDZIA£ SPIS TRE CI Java 2. Techniki zaawansowane KATALOG KSI¥¯EK Autorzy: Cay S. Horstmann, Gary Cornell KATALOG ONLINE T³umaczenie: Jaromir Senczyk ISBN: 83-7197-985-1 ZAMÓW DRUKOWANY KATALOG Tytu³ orygina³u: Core Java 2 Volume 2 Advanced Features Format: B5, stron: 1122 TWÓJ KOSZYK DODAJ DO KOSZYKA Ksi¹¿ka ta dostarcza do wiadczonym programistom rozwi¹zañ niezbêdnych do pe³nego wykorzystania mo¿liwo ci Javy. To praktyczny przewodnik u³atwiaj¹cy rozwi¹zywanie nawet najbardziej z³o¿onych problemów programistycznych. Dodatkowo zawiera CENNIK I INFORMACJE zupe³nie nowy rozdzia³ po wiêcony wykorzystaniu jêzyka XML w programach pisanych w Javie oraz zaktualizowane omówienie wielu zaawansowanych mo¿liwo ci tej ZAMÓW INFORMACJE platformy — od kolekcji po metody macierzyste, od bezpieczeñstwa po bibliotekê Swing. O NOWO CIACH Autorzy identyfikuj¹ problemy najczê ciej napotykane przez do wiadczonych programistów Javy i dostarczaj¹ przemy lanych rozwi¹zañ zilustrowanych przyk³adami ZAMÓW CENNIK kodu, które uczyni³y z tej ksi¹¿ki prawdziwy bestseller. Dziêki niej ujrzysz w nowym wietle zagadnienia interfejsu ODBC™, tworzenia aplikacji sieciowych, wykorzystania zdalnych obiektów i wiele innych. CZYTELNIA Najwa¿niejsze informacje dla programistów Java: FRAGMENTY KSI¥¯EK ONLINE • Zaktualizowane omówienie wielow¹tkowo ci, kolekcji i aplikacji sieciowych. • Zmienione przedstawienie problematyki zdalnych obiektów. • Nowe, zaawansowane techniki wykorzystania architektury komponentów JavaBeans™. • Zaawansowane techniki tworzenia interfejsu u¿ytkownika wykorzystuj¹ce biblioteki Swing i AWT. Ksi¹¿ka bêdzie dla Ciebie kolejnym krokiem w poznaniu mo¿liwo ci Javy. Jest rozszerzeniem i doskona³ym uzupe³nieniem publikacji „Java 2. Postawy”. Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl
  2. 2. Spis treści Podziękowania................................................................................................................................9 Przedmowa ................................................................................................................................... 11 Do Czytelnika ........................................................................................................................ 11 O książce............................................................................................................................... 11 Rozdział 1. Wielowątkowość ...........................................................................................................15 Czym są wątki? ..................................................................................................................... 16 Zastosowanie wątków...................................................................................................... 21 Uruchamianie i wykonywanie wątków............................................................................... 22 Wykonywanie wielu wątków.............................................................................................. 27 Interfejs Runnable ........................................................................................................... 28 Przerywanie wątków............................................................................................................... 30 Właściwości wątków .............................................................................................................. 32 Stany wątków................................................................................................................... 32 Odblokowanie wątku........................................................................................................ 35 Wątki martwe................................................................................................................... 35 Wątki-demony .................................................................................................................. 36 Grupy wątków .................................................................................................................. 36 Priorytety wątków................................................................................................................... 38 Wątki egoistyczne.................................................................................................................. 45 Synchronizacja ...................................................................................................................... 51 Komunikacja między wątkami bez synchronizacji............................................................. 51 Synchronizacja dostępu do współdzielonych zasobów ..................................................... 55 Blokady obiektów............................................................................................................. 60 Metody wait i notify.......................................................................................................... 61 Bloki synchronizowane..................................................................................................... 66 Synchronizowane metody statyczne................................................................................. 67 Zakleszczenia........................................................................................................................ 68 Dlaczego metody stop i suspend nie są zalecane? ......................................................... 71 Limity czasu..................................................................................................................... 76 Programowanie interfejsu użytkownika przy użyciu wątków.................................................... 77 Wątki i Swing ................................................................................................................... 77 Animacja.......................................................................................................................... 85 Liczniki czasu................................................................................................................... 91 Paski postępu.................................................................................................................. 94 Monitory postępu............................................................................................................. 99 Monitorowanie postępu strumieni wejścia ..................................................................... 103 Zastosowanie potoków do komunikacji pomiędzy wątkami ................................................. 109
  3. 3. 4 Java 2. Techniki zaawansowane Rozdział 2. Kolekcje ..................................................................................................................... 115 Interfejsy kolekcji................................................................................................................. 115 Rozdzielenie interfejsów kolekcji od ich implementacji .................................................. 116 Interfejsy Collection i Iterator w bibliotekach języka Java............................................... 118 Kolekcje konkretne.............................................................................................................. 123 Listy powiązane ............................................................................................................. 123 Klasa ArrayList............................................................................................................... 132 Zbiory z kodowaniem mieszającym ................................................................................ 132 Zbiory drzewiaste........................................................................................................... 139 Mapy.............................................................................................................................. 145 Specjalizowane klasy map ............................................................................................. 150 Szkielet kolekcji................................................................................................................... 155 Widoki i opakowania ...................................................................................................... 158 Operacje masowe .......................................................................................................... 164 Wykorzystanie biblioteki kolekcji z tradycyjnymi bibliotekami ......................................... 165 Algorytmy............................................................................................................................. 166 Sortowanie i tasowanie.................................................................................................. 167 Wyszukiwanie binarne.................................................................................................... 170 Proste algorytmy ............................................................................................................ 171 Programowanie własnych algorytmów ............................................................................ 173 Tradycyjne kolekcje ............................................................................................................. 174 Klasa Hashtable ............................................................................................................ 174 Wyliczenia...................................................................................................................... 175 Zbiory właściwości ......................................................................................................... 176 Stosy ............................................................................................................................. 182 Zbiory bitów ................................................................................................................... 182 Rozdział 3. Programowanie aplikacji sieciowych..........................................................................187 Połączenia z serwerem........................................................................................................ 188 Implementacja serwerów..................................................................................................... 191 Obsługa wielu klientów .................................................................................................. 194 Wysyłanie poczty elektronicznej........................................................................................... 197 Zaawansowane programowanie przy użyciu gniazdek sieciowych ........................................ 202 Połączenia wykorzystujące URL ........................................................................................... 207 URL i URI ....................................................................................................................... 208 Zastosowanie klasy URLConnection do pobierania informacji ....................................... 210 Wysyłanie danych do formularzy .......................................................................................... 219 Skrypty CGI i serwlety .................................................................................................... 219 Wysyłanie danych do serwera stron internetowych ........................................................ 221 Zbieranie informacji w sieci Internet.................................................................................... 227 Bezpieczeństwo apletów................................................................................................ 233 Serwery proxy ................................................................................................................ 236 Testowanie apletu prognozy pogody .............................................................................. 243 Rozdział 4. Połączenia do baz danych: JDBC .................................................................................247 Architektura JDBC................................................................................................................ 248 Typowe zastosowania JDBC ........................................................................................... 251 Język SQL ............................................................................................................................ 252 Instalacja JDBC ................................................................................................................... 258 Podstawowe koncepcje programowania przy użyciu JDBC ................................................... 258 Adresy URL baz danych.................................................................................................. 259 Nawiązywanie połączenia............................................................................................... 259
  4. 4. Spis treści 5 Wykonywanie poleceń języka SQL .................................................................................. 264 Zaawansowane typy języka SQL (JDBC 2) ...................................................................... 266 Wypełnianie bazy danych ............................................................................................... 268 Wykonywanie zapytań.......................................................................................................... 272 Przewijalne i aktualizowalne zbiory wyników zapytań ........................................................... 282 Przewijalne zbiory rekordów (JDBC 2) ............................................................................. 283 Aktualizowalne zbiory rekordów (JDBC 2) ....................................................................... 286 Metadane............................................................................................................................ 290 Transakcje........................................................................................................................... 300 Aktualizacje wsadowe (JDBC 2)...................................................................................... 301 Zaawansowane zarządzanie połączeniami........................................................................... 302 Rozdział 5. Obiekty zdalne ...........................................................................................................305 Wprowadzenie do problematyki obiektów zdalnych: role klienta i serwera ..................... 306 Wywołania zdalnych metod (RMI)......................................................................................... 308 Namiastka i szeregowanie parametrów ......................................................................... 309 Dynamiczne ładowanie klas ........................................................................................... 311 Konfiguracja wywołania zdalnych metod .............................................................................. 311 Interfejsy i implementacje.............................................................................................. 312 Odnajdywanie obiektów serwera .................................................................................... 315 Po stronie klienta........................................................................................................... 319 Przygotowanie wdrożenia ............................................................................................... 323 Wdrożenie programu ...................................................................................................... 326 Przekazywanie parametrów zdalnym metodom .................................................................... 326 Przekazywanie lokalnych obiektów ................................................................................. 326 Przekazywanie zdalnych obiektów .................................................................................. 338 Wykorzystanie zdalnych obiektów w zbiorach................................................................. 341 Klonowanie zdalnych obiektów....................................................................................... 342 Niewłaściwe zdalne parametry....................................................................................... 343 Wykorzystanie RMI w apletach ............................................................................................ 344 Aktywacja obiektów serwera................................................................................................ 348 Java IDL i CORBA................................................................................................................. 355 Język IDL........................................................................................................................ 356 Przykład aplikacji CORBA ............................................................................................... 361 Implementacja serwerów CORBA ................................................................................... 370 Rozdział 6. Zaawansowane mo liwości pakietu Swing .................................................................377 Listy..................................................................................................................................... 377 Komponent JList ............................................................................................................ 378 Modele list..................................................................................................................... 382 Wstawianie i usuwanie .................................................................................................. 387 Odrysowywanie zawartości listy...................................................................................... 389 Drzewa ................................................................................................................................ 394 Najprostsze drzewa........................................................................................................ 395 Przeglądanie węzłów ...................................................................................................... 410 Rysowanie węzłów ......................................................................................................... 412 Nasłuchiwanie zdarzeń w drzewach ............................................................................... 419 Własne modele drzew.................................................................................................... 425 Tabele ................................................................................................................................. 433 Najprostsze tabele......................................................................................................... 433 Modele tabel.................................................................................................................. 437 Filtry sortujące ............................................................................................................... 447
  5. 5. 6 Java 2. Techniki zaawansowane Rysowanie i edytowanie zawartości komórek................................................................. 454 Operacje na wierszach i kolumnach............................................................................... 469 Wybór wierszy, kolumn i komórek .................................................................................. 470 Komponenty formatujące tekst ........................................................................................... 478 Organizatory komponentów ................................................................................................. 484 Panele dzielone ............................................................................................................. 485 Panele z zakładkami ...................................................................................................... 489 Panele pulpitu i ramki wewnętrzne................................................................................. 494 Rozmieszczenie kaskadowe i sąsiadujące..................................................................... 497 Zgłaszanie weta do zmiany właściwości......................................................................... 500 Rozdział 7. Zaawansowane mo liwości biblioteki AWT ..................................................................513 Potokowe tworzenie grafiki .................................................................................................. 514 Figury................................................................................................................................... 516 Wykorzystanie klas obiektów graficznych ....................................................................... 518 Pola ..................................................................................................................................... 531 Ślad pędzla ......................................................................................................................... 535 Wypełnienia......................................................................................................................... 543 Przekształcenia układu współrzędnych ................................................................................ 549 Przycinanie .......................................................................................................................... 557 Przezroczystość i składanie obrazów ................................................................................... 562 Wskazówki operacji graficznych........................................................................................... 570 Czytanie i zapisywanie plików graficznych............................................................................ 575 Wykorzystanie obiektów zapisu i odczytu plików graficznych.......................................... 576 Odczyt i zapis plików zawierających sekwencje obrazów ................................................ 578 Operacje na obrazach.......................................................................................................... 588 Dostęp do danych obrazu .............................................................................................. 588 Filtrowanie obrazów ....................................................................................................... 595 Drukowanie ......................................................................................................................... 604 Drukowanie grafiki ......................................................................................................... 604 Drukowanie wielu stron.................................................................................................. 614 Podgląd wydruku............................................................................................................ 616 Usługi drukowania ......................................................................................................... 625 Usługi drukowania za pośrednictwem strumieni ............................................................ 631 Atrybuty drukowania....................................................................................................... 636 Schowek.............................................................................................................................. 643 Klasy i interfejsy umożliwiające przekazywanie danych .................................................. 644 Przekazywanie tekstu..................................................................................................... 644 Interfejs Transferable i formaty danych.......................................................................... 649 Przekazywanie obrazów za pomocą schowka ................................................................. 651 Wykorzystanie lokalnego schowka do przekazywania referencji obiektów ...................... 656 Wykorzystanie schowka systemowego do przekazywania obiektów Java ....................... 662 Mechanizm „przeciągnij i upuść”......................................................................................... 666 Cele mechanizmu „przeciągnij i upuść” ......................................................................... 668 Źródła mechanizmu „przeciągnij i upuść” ...................................................................... 677 Przekazywanie danych pomiędzy komponentami Swing ................................................. 683 Rozdział 8. JavaBeans.................................................................................................................687 Dlaczego ziarnka? ............................................................................................................... 688 Proces tworzenia ziarnek JavaBeans ................................................................................... 689 Wykorzystanie ziarnek do tworzenia aplikacji....................................................................... 693 Umieszczanie ziarnek w plikach JAR .............................................................................. 694 Korzystanie z ziarnek ..................................................................................................... 696
  6. 6. Spis treści 7 Wzorce nazw właściwości ziarnek i zdarzeń......................................................................... 701 Typy właściwości ziarnek ..................................................................................................... 703 Właściwości proste ........................................................................................................ 703 Właściwości indeksowane ............................................................................................. 704 Właściwości powiązane ................................................................................................. 705 Właściwości ograniczone ............................................................................................... 711 Tworzenie własnych zdarzeń związanych z ziarnkami........................................................... 721 Edytory właściwości ............................................................................................................. 727 Implementacja edytora właściwości ............................................................................... 735 Klasa informacyjna ziarnka.................................................................................................. 749 Klasa FeatureDescriptor ................................................................................................ 751 Indywidualizacja ziarnka ...................................................................................................... 758 Implementacja klasy indywidualizacji ............................................................................. 760 Kontekst ziarnka ................................................................................................................. 768 Zaawansowane zastosowanie introspekcji..................................................................... 768 Odnajdywanie ziarnek siostrzanych................................................................................ 771 Korzystanie z usług kontekstu ziarnka ........................................................................... 773 Rozdział 9. Bezpieczeństwo.........................................................................................................783 Ładowanie klas.................................................................................................................... 784 Implementacja własnej procedury ładującej................................................................... 787 Weryfikacja kodu maszyny wirtualnej................................................................................... 794 Menedżery bezpieczeństwa i pozwolenia............................................................................. 799 Bezpieczeństwo na platformie Java 2 ............................................................................ 801 Pliki polityki bezpieczeństwa.......................................................................................... 806 Tworzenie własnych klas pozwoleń ................................................................................ 813 Implementacja klasy pozwoleń ...................................................................................... 814 Tworzenie własnych menedżerów bezpieczeństwa......................................................... 820 Uwierzytelnianie użytkowników....................................................................................... 828 Podpis cyfrowy..................................................................................................................... 834 Skróty wiadomości......................................................................................................... 834 Podpisywanie wiadomości ............................................................................................. 840 Uwierzytelnianie wiadomości ......................................................................................... 847 Certyfikaty X.509 ........................................................................................................... 849 Tworzenie certyfikatów................................................................................................... 851 Podpisywanie certyfikatów ............................................................................................. 854 Podpisywanie kodu.............................................................................................................. 861 Podpisywanie plików JAR ............................................................................................... 862 Wskazówki dotyczące wdrożenia.................................................................................... 866 Certyfikaty twórców oprogramowania ............................................................................. 867 Szyfrowanie ......................................................................................................................... 868 Szyfrowanie symetryczne ............................................................................................... 869 Szyfrowanie kluczem publicznym ................................................................................... 875 Strumienie szyfrujące .................................................................................................... 880 Rozdział 10. Internacjonalizacja...................................................................................................883 Lokalizatory ......................................................................................................................... 884 Liczby i waluty ..................................................................................................................... 890 Data i czas .......................................................................................................................... 896 Tekst ................................................................................................................................... 903 Porządek alfabetyczny.................................................................................................... 903 Granice tekstu ............................................................................................................... 910
  7. 7. 8 Java 2. Techniki zaawansowane Formatowanie komunikatów .......................................................................................... 916 Formatowanie z wariantami ........................................................................................... 920 Konwersje zbiorów znaków ............................................................................................ 924 Internacjonalizacja a pliki źródłowe programów.............................................................. 925 Zasoby ................................................................................................................................ 926 Lokalizacja zasobów ...................................................................................................... 927 Tworzenie klas zasobów ................................................................................................ 928 Lokalizacja graficznego interfejsu użytkownika .................................................................... 931 Lokalizacja apletu .......................................................................................................... 934 Rozdział 11. Metody macierzyste ..................................................................................................951 Wywołania funkcji języka C z programów w języku Java ....................................................... 953 Wykorzystanie funkcji printf............................................................................................ 954 Numeryczne parametry metod i wartości zwracane ............................................................. 959 Wykorzystanie funkcji printf do formatowania liczb ........................................................ 959 Łańcuchy znaków jako parametry ........................................................................................ 961 Wywołanie funkcji sprintf przez metodę macierzystą...................................................... 964 Dostęp do składowych obiektu............................................................................................ 966 Dostęp do statycznych składowych klasy ............................................................................ 969 Sygnatury ............................................................................................................................ 971 Wywoływanie metod języka Java.......................................................................................... 973 Wywoływanie metod obiektów........................................................................................ 973 Wywoływanie metod statycznych.................................................................................... 976 Konstruktory .................................................................................................................. 977 Alternatywne sposoby wywoływania metod .................................................................... 977 Tablice................................................................................................................................. 980 Obsługa błędów................................................................................................................... 984 Interfejs programowy wywołań języka Java .......................................................................... 989 Kompletny przykład: dostęp do rejestru systemu Windows ................................................. 992 Rejestr systemu Windows.............................................................................................. 992 Interfejs dostępu do rejestru na platformie Java............................................................ 994 Implementacja dostępu do rejestru za pomocą metod macierzystych ........................... 995 Rozdział 12. Język XML ..............................................................................................................1009 Wprowadzenie do języka XML............................................................................................ 1010 Struktura dokumentu XML ........................................................................................... 1012 Parsowanie dokumentów XML........................................................................................... 1015 Definicje typów dokumentów ............................................................................................. 1026 Praktyczny przykład ...................................................................................................... 1034 Przestrzenie nazw.............................................................................................................. 1046 Wykorzystanie parsera SAX ............................................................................................... 1048 Tworzenie dokumentów XML ............................................................................................. 1053 Przekształcenia XSL .......................................................................................................... 1061 Skorowidz.................................................................................................................................1073
  8. 8. 6 Zaawansowane mo liwości pakietu Swing W tym rozdziale: n Listy. n Drzewa. n Tabele. n Komponenty formatujące tekst. n Organizatory komponentów. W rozdziale tym kontynuować będziemy rozpoczęte w ksią ce Java 2. Podstawy omówienie pakietu Swing wykorzystywanego do tworzenia interfejsu u ytkownika. Pakiet Swing posiada bardzo rozbudowane mo liwości, a w ksią ce Java 2. Podstawy zdołaliśmy przedstawić jedy- nie komponenty najczęściej u ywane. Większość niniejszego rozdziału poświęcimy zło onym komponentom, takim jak listy, drzewa i tabele. Komponenty umo liwiające formatowanie tek- stu, na przykład HTML, posiadają jeszcze bardziej zło oną implementację. Omówimy sposób ich praktycznego wykorzystania. Rozdział zakończymy przedstawieniem organizatorów kom- ponentów, takich jak panele z zakładkami i panele z wewnętrznymi ramkami. Listy Prezentując u ytkownikowi zbiór elementów do wyboru, mo emy skorzystać z ró nych kom- ponentów. Jeśli zbiór ten zawierać będzie wiele elementów, to ich przedstawienie za pomocą pól wyboru zajmie zdecydowanie za du o miejsca w oknie programu. Skorzystamy wtedy zwykle z listy bądź listy rozwijalnej. Listy rozwijalne są stosunkowo prostymi komponentami i dlatego omówiliśmy je ju w ksią ce Java 2. Podstawy. Natomiast listy reprezentowane przez komponent ,.KUV posiadają du o większe mo liwości, a sposób ich u ycia przypomina korzystanie z innych zło onych komponentów, takich jak drzewa czy tabele. Dlatego właśnie od list rozpoczniemy omówienie zło onych komponentów pakietu Swing.
  9. 9. 378 Java 2. Techniki zaawansowane Listy często składają się z łańcuchów znaków, ale w praktyce zawierać mogą dowolne obiekty i kontrolować przy tym sposób ich prezentacji. Wewnętrzna architektura listy, która umo li- wia taki stopień ogólności, prezentuje się dość elegancko. Niestety projektanci z firmy Sun postanowili pochwalić się elegancją tworzonych rozwiązań, zamiast ukryć ją przed programi- stami korzystającymi z komponentu. Skutkiem tego posługiwanie się listami w najprostszych przypadkach jest trochę skomplikowane, poniewa programista musi manipulować mechani- zmami, które umo liwiają wykorzystanie list w bardziej zło onych przypadkach. Omówienie rozpoczniemy od przedstawienia najprostszego i najczęściej spotykanego zastosowania tego komponentu — listy, której elementami są łańcuchy znaków. Później przejdziemy do bardziej zło onych przykładów ilustrujących uniwersalność komponentu. Komponent JList Zastosowanie komponentu ,.KUV przypomina u ycie zbioru komponentów, takich jak przy- ciski lub pola wyboru. Ró nica polega na tym, e elementy listy umieszczone są we wspól- nej ramce, a wyboru dokonuje się, wskazując dany element, a nie związane z nim pole bądź przycisk. U ytkownik mo e te wybrać wiele elementów listy, jeśli pozwolimy na to. Rysunek 6.1 pokazuje najprostszy przykład listy. U ytkownik mo e z niej wybrać atrybuty opisujące lisa, takie jak „quick”, „brown”, „hungry” i „wild” oraz, z braku innych pomy- słów, „static”, „private” i „final”. Rysunek 6.1. Komponent klasy JList Tworzenie listy rozpoczynamy od skonstruowania tablicy łańcuchów znaków, którą na- stępnie przekazujemy konstruktorowi klasy ,.KUV: 5VTKPI=? YQTFU ] SWKEM DTQYP JWPIT[ YKNF _ ,.KUV YQTF.KUV PGY ,.KUV YQTFU Mo emy wykorzystać w tym celu tak e anonimową tablicę: ,.KUV YQTF.KUV PGY ,.KUV PGY 5VTKPI=? ] SWKEM DTQYP JWPIT[ YKNF _ Komponenty ,.KUV nie przewijają automatycznie swojej zawartości. W tym celu musimy umieścić listę w panelu przewijalnym: ,5ETQNN2CPG UETQNN2CPG PGY ,5ETQNN2CPG YQTF.KUV
  10. 10. Rozdział 6. n Zaawansowane mo liwości pakietu Swing 379 Panel ten, a nie listę, umieszczamy następnie na docelowym panelu okna. Rozdzielenie prezentacji listy od mechanizmu przewijania jest z pewnością rozwiązaniem eleganckim, ale mało praktycznym. Właściwie prawie wszystkie listy wymagają przewija- nia. Zmuszanie programistów, by za ka dym razem, gdy tworzą najprostszą listę, podzi- wiali działanie tego mechanizmu, jest okrutne. Domyślnie lista mieści osiem elementów widocznych jednocześnie. Mo emy to zmienić, korzystając z metody UGV8KUKDNG4QY%QWPV: YQTF.KUVUGV8KUKDNG4QY%QWPV RQMCWLG LGFPQEG PKG GNGOGPVÎY Domyślnie u ytkownik mo e wybierać wiele elementów listy. Wymaga to od niego za- awansowanego posługiwania się myszą: wybierając kolejne elementy, musi jednocześnie wciskać klawisz Ctrl. Aby wytypować pewien ciągły zakres elementów, u ytkownik po- winien zaznaczyć pierwszy z nich a następnie, wciskając klawisz Shift, wybrać ostatni z elementów. Mo liwość wyboru elementów przez u ytkownika mo emy ograniczyć, korzystając z me- tody UGV5GNGEVKQP/QFG: YQTF.KUVUGV5GNGEVKQP/QFG .KUV5GNGEVKQP/QFGN5+0).'A5'.'%6+10 OQ NKYQ è Y[DQTW RQLGF[PEGIQ GNGOGPVW YQTF.KUVUGV5GNGEVKQP/QFG .KUV5GNGEVKQP/QFGN5+0).'A+06'48#.A5'.'%6+10 OQ NKYQ è Y[DQTW RQLGF[PEGIQ GNGOGPVW NWD RQLGF[PEGIQ CMTGUW GNGOGPVÎY Z lektury ksią ki Java 2. Podstawy przypominamy sobie z pewnością, e podstawowe ele- menty interfejsu u ytkownika generują zdarzenia akcji w momencie ich aktywacji przez u ytkownika. Listy wykorzystują jednak inny mechanizm powiadomień. Zamiast nasłu- chiwać zdarzeń akcji, w przypadku list nasłuchiwać będziemy zdarzeń wyboru na liście. W tym celu musimy dodać do komponentu listy obiekt nasłuchujący wyboru i zaimple- mentować następującą metodę obiektu nasłuchującego: RWDNKE XQKF XCNWG%JCPIGF .KUV5GNGEVKQP'XGPV GXV Podczas dokonywania wyboru na liście generuje się sporo zdarzeń. Załó my na przykład, e u ytkownik przechodzi do kolejnego elementu listy. Gdy naciska klawisz myszy, gene- rowane jest zdarzenie zmiany wyboru na liście. Zdarzenie to jest przejściowe i wywołanie metody GXGPVKU#FLWUVKPI zwraca wartość VTWG, gdy wybór nie jest ostateczny. Gdy u ytkownik puszcza klawisz my- szy, generowane jest kolejne zdarzenie, dla którego wywołanie metody KU#FLWUVKPI zwróci tym razem wartość HCNUG. Jeśli nie jesteśmy zainteresowani przejściowymi zdarzeniami na liście, to wystarczy poczekać jedynie na zdarzenie, dla którego metoda KU#FLWUVKPI zwróci właśnie wartość HCNUG. W przeciwnym razie musimy obsługiwać wszystkie zdarzenia. Zwykle po zawiadomieniu o zdarzeniu będziemy chcieli się dowiedzieć, które elementy zo- stały wybrane. Metoda IGV5GNGEVGF8CNWGU zwraca tablicę obiektów zawierającą wybrane elementy.
  11. 11. 380 Java 2. Techniki zaawansowane Ka dy z jej elementów musimy rzutować na łańcuch znaków. 1DLGEV=? XCNWGU NKUVIGV5GNGEVGF8CNWGU HQT KPV K K XCNWGUNGPIVJ K RTGVYCTCPKG GNGOGPVÎY RQUVCEK 5VTKPIXCNWGU=K? Nie możemy rzutować tablicy 1DLGEV=? zwróconej przez metodę IGV5GNGEVGF8CNWGU na tablicę 5VTKPI=?. Zwracana przez metodę tablica została utworzona nie jako tablica łańcuchów znaków, ale jako tablica obiektów, z których każdy jest akurat łańcuchem znaków. Jeśli chcemy przetwarzać zwróconą tablicę jako tablicę łańcuchów znaków, to powinniśmy skorzystać z poniższego kodu: KPV NGPIVJ XCNWGUNGPIVJ 5VTKPI=? YQTFU PGY 5VTKPI=NGPIVJ? 5[UVGOCTTC[%QR[ XCNWGU YQTFU NGPIVJ Jeśli lista nie dopuszcza wyboru wielu elementów, to mo emy skorzystać z metody IGV5G NGEVGF8CNWG. Zwraca ona pierwszy element wybrany na liście. 5VTKPI UGNGEVKQP 5VTKPIUQWTEGIGV5GNGEVGF8CNWG Listy nie obsługują dwukrotnych kliknięć myszą. Projektanci pakietu Swing założyli, że na liście dokonuje się jedynie wyboru, a następnie zaznacza się komponent przycisku, aby wykonać jakąś akcję. Niektóre interfejsy użytkownika posiadają możliwość dwu- krotnego kliknięcia elementu listy w celu dokonania jego wyboru i wykonania na nim pewnej akcji. Uważamy, że nie jest to zbyt dobry styl tworzenia interfejsu użytkownika, ponieważ wymaga, by użytkownik samodzielnie odkrył możliwość takiego jego działa- nia. Jeśli jednak z pewnych powodów chcemy skorzystać z możliwości implementacji takiego zachowania listy, to musimy dodać do niej obiekt nasłuchujący mysz i obsłu- giwać zdarzenia myszy w następujący sposób: RWDNKE XQKF OQWUG%NKEMGF /QWUG'XGPV GXV ] KH GXVIGV%NKEM%QWPV ] ,.KUV UQWTEG ,.KUVGXVIGV5QWTEG 1DLGEV=? UGNGEVKQP UQWTEGIGV5GNGEVGF8CNWGU FQ#EVKQP UGNGEVKQP _ _ Listing 6.1 zawiera tekst źródłowy programu demonstrującego wykorzystanie listy wypeł- nionej łańcuchami znaków. Zwróćmy uwagę na sposób, w jaki metoda XCNWG%JCPIGF two- rzy łańcuch komunikatu z wybranych elementów listy. Listing 6.1. ListTest.java KORQTV LCXCCYV
  12. 12. KORQTV LCXCCYVGXGPV
  13. 13. KORQTV LCXCZUYKPI
  14. 14. KORQTV LCXCZUYKPIGXGPV
  15. 15. 2TQITCO FGOQPUVTWLæE[ Y[MQT[UVCPKG NKUV[ CYKGTCLæEGL C EWEJ[ PCMÎY
  16. 16. RWDNKE ENCUU .KUV6GUV
  17. 17. Rozdział 6. n Zaawansowane mo liwości pakietu Swing 381 ] RWDNKE UVCVKE XQKF OCKP 5VTKPI=? CTIU ] ,(TCOG HTCOG PGY .KUV(TCOG HTCOGUGVGHCWNV%NQUG1RGTCVKQP ,(TCOG':+6A10A%.15' HTCOGUJQY _ _
  18. 18. 4COMC CYKGTCLæEC NKUVú U ÎY K GV[MKGVú RQMCWLæEæ FCPKG Q QPG Y[DTCP[EJ U ÎY 2T[VT[OWLæE MNCYKU %VTN Y[DTCè OQ PC YKGNG U ÎY C MNCYKU 5JKHV RQYCNC PC Y[DÎT EC GIQ CMTGUW U ÎY
  19. 19. ENCUU .KUV(TCOG GZVGPFU ,(TCOG ] RWDNKE .KUV(TCOG ] UGV6KVNG .KUV6GUV UGV5KG 9+6* *'+)*6 5VTKPI=? YQTFU ] SWKEM DTQYP JWPIT[ YKNF UKNGPV JWIG RTKXCVG CDUVTCEV UVCVKE HKPCN _ YQTF.KUV PGY ,.KUV YQTFU ,5ETQNN2CPG UETQNN2CPG PGY ,5ETQNN2CPG YQTF.KUV ,2CPGN R PGY ,2CPGN RCFF UETQNN2CPG YQTF.KUVCFF.KUV5GNGEVKQP.KUVGPGT PGY .KUV5GNGEVKQP.KUVGPGT ] RWDNKE XQKF XCNWG%JCPIGF .KUV5GNGEVKQP'XGPV GXGPV ] 1DLGEV=? XCNWGU YQTF.KUVIGV5GNGEVGF8CNWGU 5VTKPI$WHHGT VGZV PGY 5VTKPI$WHHGT RTGHKZ HQT KPV K K XCNWGUNGPIVJ K ] 5VTKPI YQTF 5VTKPIXCNWGU=K? VGZVCRRGPF YQTF VGZVCRRGPF _ VGZVCRRGPF UWHHKZ NCDGNUGV6GZV VGZVVQ5VTKPI _ _ %QPVCKPGT EQPVGPV2CPG IGV%QPVGPV2CPG EQPVGPV2CPGCFF R $QTFGT.C[QWV5176* NCDGN PGY ,.CDGN RTGHKZ UWHHKZ EQPVGPV2CPGCFF NCDGN $QTFGT.C[QWV%'06'4 _
  20. 20. 382 Java 2. Techniki zaawansowane RTKXCVG UVCVKE HKPCN KPV 9+6* RTKXCVG UVCVKE HKPCN KPV *'+)*6 RTKXCVG ,.KUV YQTF.KUV RTKXCVG ,.CDGN NCDGN RTKXCVG 5VTKPI RTGHKZ 6JG RTKXCVG 5VTKPI UWHHKZ HQZ LWORU QXGT VJG NC[ FQI _ LCXCZUYKPI,.KUV n ,.KUV 1DLGEV=? KVGOU tworzy listę wyświetlającą podane elementy. n XQKF UGV8KUKDNG4QY%QWPV KPV E określa liczbę elementów widocznych jednocześnie na liście (bez przewijania). n XQKF UGV5GNGEVKQP/QFG KPV OQFG określa mo liwość wyboru pojedynczego lub wielu elementów. Parametry: OQFG jedna z wartości 5+0).'A5'.'%6+10 5+0).'A+06'48#.A5'.'%6+10 /7.6+2.'A+06'48#.A5'.'%6+10. n XQKF CFF.KUV5GNGEVKQP.KUVGPGT .KUV5GNGEVKQP.KUVGPGT NKUVGPGT dodaje do listy obiekt nasłuchujący zdarzeń wyboru na liście. n 1DLGEV=? IGV5GNGEVGF8CNWGU zwraca elementy wybrane na liście lub pustą tablicę, jeśli aden element nie został wybrany. n 1DLGEV IGV5GNGEVGF8CNWG zwraca pierwszy element wybrany na liście lub wartość PWNN. LCXCZUYKPIGXGPV.KUV5GNGEVKQP.KUVGPGT n XQKF XCNWG%JCPIGF .KUV5GNGEVKQP'XGPV G metoda wywoływana za ka dym razem, gdy wybór na liście uległ zmianie. Modele list W poprzednim podrozdziale pokazaliśmy najczęściej spotykany sposób wykorzystania list polegający na: n utworzeniu niezmiennego zbioru elementów listy (łańcuchów znaków), n umo liwieniu przewijania listy, n obsłudze zdarzeń wyboru elementów listy. W dalszej części przedstawimy bardziej skomplikowane sposoby wykorzystania list, czyli: n listy o bardzo du ej liczbie elementów, n listy o zmiennej zawartości, n listy zawierające elementy inne ni łańcuchy znaków.
  21. 21. Rozdział 6. n Zaawansowane mo liwości pakietu Swing 383 W naszym pierwszym przykładzie utworzyliśmy listę zawierającą określony zbiór łańcu- chów znaków. Często jednak zachodzi potrzeba dodawania nowych elementów listy bądź usuwania elementów ju umieszczonych na liście. Zaskakujący mo e wydać się fakt, e klasa ,.KUV nie zawiera metod umo liwiających takie operacje na liście. Aby zrozumieć te- go przyczynę, musimy zapoznać się bli ej z wewnętrzną architekturą komponentu listy. Podobnie jak w przypadku komponentów tekstowych tak e i lista jest przykładem zastoso- wania wzorca model-widok-nadzorca w celu oddzielenia wizualizacji listy (czyli kolumny elementów wyświetlonych w pewien sposób) od danych (kolekcji obiektów). Klasa ,.KUV odpowiedzialna jest jedynie za wizualizację danych i niewiele wie na temat ich reprezentacji. Potrafi jedynie pobrać dane, korzystając z obiektu implementującego interfejs .KUV/QFGN: RWDNKE KPVGTHCEG .KUV/QFGN ] RWDNKE KPV IGV5KG RWDNKE 1DLGEV IGV'NGOGPV#V KPV K RWDNKE XQKF CFF.KUVCVC.KUVGPGT .KUVCVC.KUVGPGT N RWDNKE XQKF TGOQXG.KUVCVC.KUVGPGT .KUVCVC.KUVGPGT N _ Wykorzystując ten interfejs, komponent klasy ,.KUV mo e określić liczbę elementów i po- brać ka dy z nich. Mo e tak e dodać się jako obiekt nasłuchujący danych. Dzięki temu bę- dzie powiadamiany o ka dej zmianie w kolekcji elementów i będzie mógł aktualizować re- prezentację list na ekranie. Jaki jest cel takiego rozwiązania? Dlaczego komponent ,.KUV nie przechowuje po prostu swoich elementów za pomocą wektora? Zwróćmy uwagę, e interfejs nie określa sposobu przechowywania obiektów. W szczegól- ności nie wymaga on nawet, by obiekty były przechowywane! Metoda IGV'NGOGPV#V mo e wyznaczać wartość elementu od nowa, za ka dym razem gdy jest wywoływana. Mo e oka- zać się to przydatne, jeśli lista prezentować ma bardzo liczną kolekcję danych, których nie chcemy przechowywać. A oto najprostszy przykład: lista umo liwiać będzie u ytkownikowi wybór spośród wszyst- kich mo liwych kombinacji trzech liter (patrz rysunek 6.2). Rysunek 6.2. Wybór z listy zawierającej dużą liczbę elementów
  22. 22. 384 Java 2. Techniki zaawansowane Istnieje 26 ∗ 26 ∗ 26 = 17 576 takich kombinacji. Zamiast przechowywać je wszystkie, program będzie tworzył je podczas przewijania listy przez u ytkownika. Implementacja programu okazuje się bardzo prosta. Zadanie dodania i usuwania odpo- wiednich obiektów nasłuchujących wykona za nas klasa #DUVTCEV.KUV/QFGN, którą roz- szerzymy. Naszym zadaniem będzie jedynie dostarczenie implementacji metod IGV5KG i IGV'NGOGPV#V: ENCUU 9QTF.KUV/QFGN GZVGPFU #DUVTCEV.KUV/QFGN ] RWDNKE 9QTF.KUV/QFGN KPV P ] NGPIVJ P _ RWDNKE KPV IGV5KG ] TGVWTP KPV/CVJRQY NGPIVJ _ RWDNKE 1DLGEV IGV'NGOGPV#V KPV P ] Y[PCEC PV[ C EWEJ _ _ Wyznaczenie n-tego łańcucha jest trochę skomplikowane — szczegóły znajdziemy w tek- ście programu umieszczonym w listingu 6.2. Po utworzeniu modelu listy łatwo wykreować taką listę, która pozwoli u ytkownikowi na przeglądanie wartości dostarczanych przez model: YQTF.KUV PGY ,.KUV PGY 9QTF.KUV/QFGN YQTF.KUVUGV5GNGEVKQP/QFG .KUV5GNGEVKQP/QFGN5+0).'A5'.'%6+10 ,5ETQNN2CPG UETQNN2CPG PGY ,5ETQNN2CPG YQTF.KUV Zaletą programu jest to, e prezentowane na liście łańcuchy nie są nigdzie przechowywane. Generowane są jedynie elementy listy widoczne w danym momencie dla u ytkownika. Musimy jeszcze dostarczyć do listy informację, e ka dy z jej elementów posiada stałą sze- rokość i wysokość. YQTF.KUVUGV(KZGF%GNN9KFVJ YQTF.KUVUGV(KZGF%GNN*GKIJV W przeciwnym razie lista będzie wyznaczać te wartości dla ka dego elementu, co będzie zbyt czasochłonne. W praktyce listy zawierające tak du ą liczbę elementów są rzadko przydatne, poniewa przeglądanie ich jest kłopotliwe dla u ytkownika. Dlatego te uwa amy, e projektanci list pakietu Swing przesadzili nieco z ich uniwersalnością. Liczba elementów, które u ytkow- nik mo e wygodnie przeglądać na ekranie, jest tak mała, e mogłyby one być przechowy- wane po prostu wewnątrz komponentu listy. Oszczędziłoby to programistom tworzenia modeli list. Z drugiej jednak strony zastosowane rozwiązanie sprawia, e sposób wykorzy- stania komponentu ,.KUV jest spójny ze sposobami u ywania komponentów ,6TGG i ,6CDNG, w przypadku których taka uniwersalność okazuje się przydatna.
  23. 23. Rozdział 6. n Zaawansowane mo liwości pakietu Swing 385 Listing 6.2. LongListTest.java KORQTV LCXCCYV
  24. 24. KORQTV LCXCCYVGXGPV
  25. 25. KORQTV LCXCZUYKPI
  26. 26. KORQTV LCXCZUYKPIGXGPV
  27. 27. 2TQITCO FGOQPUVTWLæE[ Y[MQT[UVCPKG NKUV[ MVÎTC F[PCOKEPKG Y[PCEC UYQLG GNGOGPV[
  28. 28. RWDNKE ENCUU .QPI.KUV6GUV ] RWDNKE UVCVKE XQKF OCKP 5VTKPI=? CTIU ] ,(TCOG HTCOG PGY .QPI.KUV(TCOG HTCOGUGVGHCWNV%NQUG1RGTCVKQP ,(TCOG':+6A10A%.15' HTCOGUJQY _ _
  29. 29. 4COMC CYKGTCLæEC F WIæ NKUVú U ÎY K GV[MKGVú RQMCWLæEæ FCPKG Q QPG Y[DTCP[EJ U ÎY
  30. 30. ENCUU .QPI.KUV(TCOG GZVGPFU ,(TCOG ] RWDNKE .QPI.KUV(TCOG ] UGV6KVNG .QPI.KUV6GUV UGV5KG 9+6* *'+)*6 YQTF.KUV PGY ,.KUV PGY 9QTF.KUV/QFGN YQTF.KUVUGV5GNGEVKQP/QFG .KUV5GNGEVKQP/QFGN5+0).'A5'.'%6+10 YQTF.KUVUGV(KZGF%GNN9KFVJ YQTF.KUVUGV(KZGF%GNN*GKIJV ,5ETQNN2CPG UETQNN2CPG PGY ,5ETQNN2CPG YQTF.KUV ,2CPGN R PGY ,2CPGN RCFF UETQNN2CPG YQTF.KUVCFF.KUV5GNGEVKQP.KUVGPGT PGY .KUV5GNGEVKQP.KUVGPGT ] RWDNKE XQKF XCNWG%JCPIGF .KUV5GNGEVKQP'XGPV GXV ] 5VTKPI$WHHGT YQTF 5VTKPI$WHHGTYQTF.KUVIGV5GNGEVGF8CNWG UGV5WDLGEV YQTFVQ5VTKPI _ _ %QPVCKPGT EQPVGPV2CPG IGV%QPVGPV2CPG EQPVGPV2CPGCFF R $QTFGT.C[QWV5176*
  31. 31. 386 Java 2. Techniki zaawansowane NCDGN PGY ,.CDGN RTGHKZ UWHHKZ EQPVGPV2CPGCFF NCDGN $QTFGT.C[QWV%'06'4 UGV5WDLGEV HQZ _
  32. 32. 1MTG NC RQFOKQV FCPKC RQMC[YCPGIQ C RQOQEæ GV[MKGV[ RCTCO YQTF PQY[ RQFOKQV FCPKC
  33. 33. RWDNKE XQKF UGV5WDLGEV 5VTKPI YQTF ] 5VTKPI$WHHGT VGZV PGY 5VTKPI$WHHGT RTGHKZ VGZVCRRGPF YQTF VGZVCRRGPF UWHHKZ NCDGNUGV6GZV VGZVVQ5VTKPI _ RTKXCVG UVCVKE HKPCN KPV 9+6* RTKXCVG UVCVKE HKPCN KPV *'+)*6 RTKXCVG ,.KUV YQTF.KUV RTKXCVG ,.CDGN NCDGN RTKXCVG 5VTKPI RTGHKZ 6JG SWKEM DTQYP RTKXCVG 5VTKPI UWHHKZ LWORU QXGT VJG NC[ FQI _
  34. 34. /QFGN NKUV[ F[PCOKEPKG IGPGTWLæE[ MQODKPCELG P NKVGT
  35. 35. ENCUU 9QTF.KUV/QFGN GZVGPFU #DUVTCEV.KUV/QFGN ]
  36. 36. 6YQT[ OQFGN RCTCO P F WIQ è MQODKPCELK U QYC
  37. 37. RWDNKE 9QTF.KUV/QFGN KPV P ] NGPIVJ P _ RWDNKE KPV IGV5KG ] TGVWTP KPV/CVJRQY .#56 (+456 NGPIVJ _ RWDNKE 1DLGEV IGV'NGOGPV#V KPV P ] 5VTKPI$WHHGT T PGY 5VTKPI$WHHGT HQT KPV K K NGPIVJ K ] EJCT E EJCT (+456 P .#56 (+456 TKPUGTV E P P .#56 (+456 _ TGVWTP T _ RTKXCVG KPV NGPIVJ RWDNKE UVCVKE HKPCN EJCT (+456 C RWDNKE UVCVKE HKPCN EJCT .#56 _
  38. 38. Rozdział 6. n Zaawansowane mo liwości pakietu Swing 387 LCXCZUYKPI,.KUV n ,.KUV .KUV/QFGN FCVC/QFGN tworzy listę, która wyświetla elementy dostarczane przez określony model. n XQKF UGV(KZGF%GNN9KFVJ KPV YKFVJ jeśli parametr YKFVJ ma wartość większą od zera, to określa on szerokość ka dej komórki listy. Wartością domyślną jest –1, co wymusza wyznaczenie rozmiarów ka dej komórki z osobna. n XQKF UGV(KZGF%GNN*GKIJV KPV JGKIJV jeśli parametr JGKIJV ma wartość większą od zera, to określa on wysokość ka dej komórki listy. Wartością domyślną jest –1, co wymusza wyznaczenie rozmiarów ka dej komórki z osobna. LCXCZUYKPI.KUV/QFGN n KPV IGV5KG zwraca liczbę elementów w danym modelu. n 1DLGEV IGV'NGOGPV#V KPV KPFGZ zwraca element modelu. Wstawianie i usuwanie Kolekcji elementów listy nie mo emy modyfikować bezpośrednio. Operacje te mo emy wykonywać jedynie za pośrednictwem modelu. Załó my, e chcemy umieścić na liście ko- lejne elementy. Najpierw pobierzemy referencję odpowiedniego modelu: .KUV/QFGN OQFGN NKUVIGV/QFGN Jednak interfejs .KUV/QFGN nie zawiera metod umo liwiających wstawianie i usuwanie ele- mentów, poniewa nie wymaga on przechowywania elementów listy. Spróbujmy więc inaczej. Jeden z konstruktorów klasy ,.KUV korzysta z wektora obiektów: 8GEVQT XCNWGU PGY 8GEVQT XCNWGUCFF'NGOGPV SWKEM XCNWGUCFF'NGOGPV DTQYP ,.KUV NKUV PGY ,.KUV XCNWGU Elementy wektora mo emy następnie usuwać lub dodawać, ale oczywiście lista nie zareje- struje tych operacji i wobec tego nie będzie odzwierciedlać zmian w zbiorze elementów. Nie istnieje konstruktor klasy ,.KUV, który posiadałby parametr klasy #TTC[.KUV. Jed- nak już konstrukcja komponentu listy z wykorzystaniem wektora jest rzadko przydatna i wobec tego brak ten nie stanowi istotnego ograniczenia. Rozwiązanie polega na utworzeniu modelu klasy GHCWNV.KUV/QFGN, wypełnieniu go po- czątkowymi elementami i związaniu z listą. GHCWNV.KUV/QFGN OQFGN PGY GHCWNV.KUV/QFGN OQFGNCFF'NGOGPV SWKEM OQFGNCFF'NGOGPV DTQYP ,.KUV NKUV PGY ,.KUV OQFGN
  39. 39. 388 Java 2. Techniki zaawansowane Mo emy teraz dodawać i usuwać elementy modelu, który będzie powiadamiać listę o tych zmianach. OQFGNTGOQXG'NGOGPV DTQYP OQFGNCFF'NGOGPV UNQY Jak łatwo zauwa yć, klasa GHCWNV/QFGN.KUV stosuje nazwy metod odmienne ni klasy ko- lekcji. Zastosowany model listy wykorzystuje wektor do przechowania danych. Model ten dzie- dziczy mechanizm powiadamiania listy z klasy #DUVTCEV.KUV/QFGN, podobnie jak nasza kla- sa w poprzednim podrozdziale. Dostępne są konstruktory klasy ,.KUV tworzące listę w oparciu o tablicę lub wektor obiektów. Wydawać się może, że wykorzystują one model GHCWNV.KUV/QFGN w celu przechowania elementów listy. Nie jest to prawdą. Konstruktory te korzystają z uprosz- czonego modelu, który umożliwia jedynie dostęp do elementów, ale nie posiada me- chanizmu powiadamiania o zmianach. Poniżej prezentujemy kod konstruktora klasy ,.KUV tworzącego listę na podstawie wektora: RWDNKE ,.KUV HKPCN 8GEVQT NKUVCVC ] VJKU PGY #DUVTCEV.KUV/QFGN ] RWDNKE KPV IGV5KG ] TGVWTP NKUVCVCUKG _ RWDNKE 1DLGEV IGV'GNGOGPV#V KPV K ] TGVWTP NKUVCVCGNGOGPV#V K _ _ _ Pokazuje on, że jeśli zmienimy zawartość wektora po utworzeniu listy, to pokazywać ona będzie mylącą mieszankę starych i nowych elementów, aż do momentu gdy cała lista zostanie odrysowana. (Słowo kluczowe HKPCN w deklaracji konstruktora nie za- brania wprowadzania zmian zawartości wektora w innych fragmentach kodu. Oznacza ono jedynie, że konstruktor nie modyfikuje referencji NKUVCVC. Słowo kluczowe HKPCN jest wymagane w tej deklaracji, ponieważ obiekt NKUVCVC wykorzystywany jest przez klasę wewnętrzną). LCXCZUYKPI,.KUV n .KUV/QFGN IGV/QFGN pobiera model listy. LCXCZUYKPIGHCWNV.KUV/QFGN n XQKF CFF'NGOGPV 1DLGEV QDL umieszcza obiekt na końcu danych modelu. n DQQNGCP TGOQXG'NGOGPV 1DLGEV QDL usuwa pierwsze wystąpienie obiektu z modelu. Zwraca wartość VTWG, jeśli obiekt został odnaleziony w modelu, wartość HCNUG — w przeciwnym razie.
  40. 40. Rozdział 6. n Zaawansowane mo liwości pakietu Swing 389 Odrysowywanie zawartości listy Jak dotąd wszystkie przykłady wykorzystywały listy zawierające łańcuchy znaków. W prak- tyce równie łatwo mo emy utworzyć listę ikon, dostarczając konstruktorowi tablicę lub wek- tor wypełniony obiektami klasy +EQP. W ogóle mo emy reprezentować elementy listy za po- mocą dowolnych rysunków. Klasa ,.KUV automatycznie wyświetla łańcuchy znaków oraz ikony, ale w pozostałych przy- padkach nale y dostarczyć jej obiekt odrysowujący zawartość komórek listy. Obiekt taki musi nale eć do klasy, która implementuje poni szy interfejs: KPVGTHCEG .KUV%GNN4GPFGTGT ] %QORQPGPV IGV.KUV%GNN4GPFGTGT%QORQPGPV ,.KUV NKUV 1DLGEV XCNWG KPV KPFGZ DQQNGCP KU5GNGEVGF DQQNGCP EGNN*CU(QEWU _ Jeśli liście dostarczymy taki obiekt, to jego metoda wywoływana będzie dla ka dego ele- mentu listy, aby: n ustalić jego wymiary (w przypadku gdy nie wybraliśmy listy o stałych wymiarach komórek), n narysować go. Obiekt ten musi tworzyć i zwracać obiekt typu %QORQPGPV, którego metody IGV2TGHGTTGF 5KG oraz RCKPV%QORQPGPV wykonają odpowiednie operacje wymagane dla prezentacji ele- mentów listy. Najprostszym sposobem spełnienia tego wymagania jest wykorzystanie klasy wewnętrznej dysponującej tymi metodami: ENCUU /[%GNN4GPFGTGT KORNGOGPVU .KUV%GNN4GPFGTGT ] RWDNKE %QORQPGPV IGV.KUV%GNN4GPFGTGT%QORQPGPV HKPCN ,.KUV NKUV HKPCN 1DLGEV XCNWG HKPCN KPV KPFGZ HKPCN DQQNGCP KU5GNGEVGF HKPCN DQQNGCP EGNN*CU(QEWU ] TGVWTP PGY ,2CPGN ] RWDNKE XQKF RCKPV%QORQPGPV )TCRJKEU I ] MQF T[UWLæE[ GNGOGPV _ RWDNKE KOGPUKQP IGV2TGHGTTGF5KG ] MQF Y[PCECLæE[ TQOKCT[ _ _ _ _
  41. 41. 390 Java 2. Techniki zaawansowane Program, którego kod źródłowy zawiera listing 6.3, umo liwia wybór czcionki, korzystając z jej rzeczywistego przedstawienia na liście (patrz rysunek 6.3). Metoda RCKPV%QORQPGPV wyświetla nazwę danej czcionki, wykorzystując ją samą. Musi tak e dopasować kolorysty- kę do aktualnego wyglądu klasy ,.KUV. Uzyskujemy ją, posługując się metodami IGV(QTG ITQWPFIGV$CEMITQWPF oraz IGV5GNGEVKQP(QTGITQWPFIGV5GNGEVKQP$CEMITQWPF klasy ,.KUV. Metoda IGV2TGHGTTGF5KG mierzy łańcuch znaków w sposób opisany w ksią ce Java 2. Pod- stawy w rozdziale 7. Rysunek 6.3. Lista o komórkach rysowanych przez program Obiekt rysujący komórki instalujemy za pomocą metody UGV%GNN4GPFGTGT: HQPV.KUVUGV%GNN4GPFGTGT PGY (QPV%GNN4GPFGTGT Od tego momentu wszystkie komórki listy będą rysowane przez ten obiekt. W wielu przypadkach sprawdza się prostsza metoda tworzenia obiektów rysujących ko- mórki list. Jeśli komórka składa się z tekstu, ikony i zmienia swój kolor, to wszystkie te mo liwości uzyskać mo emy, korzystając z obiektu klasy ,.CDGN. Aby na przykład pokazać nazwę czcionki za jej pomocą, mo emy skorzystać z następującego obiektu: ENCUU (QPV%GNN4GPFGTGT KORNGOGPVU .KUV%GNN4GPFGTGT ] RWDNKE %QORQPGPV IGV.KUV%GNN4GPFGTGT%QORQPGPV ,.KUV NKUV 1DLGEV XCNWG KPV KPFGZ DQQNGCP KU5GNGEVGF DQQNGCP EGNN*CU(QEWU ] ,.CDGN NCDGN PGY ,.CDGN (QPV HQPV (QPVXCNWG NCDGNUGV6GZV HQPVIGV(COKN[ NCDGNUGV(QPV HQPV NCDGNUGV1RCSWG VTWG NCDGNUGV$CEMITQWPF KU5GNGEVGF ! NKUVIGV5GNGEVKQP$CEMITQWPF NKUVIGV$CEMITQWPF NCDGNUGV(QTGITQWPF KU5GNGEVGF ! NKUVIGV5GNGEVKQP(QTGITQWPF NKUVIGV(QTGITQWPF TGVWTP NCDGN _ _
  42. 42. Rozdział 6. n Zaawansowane mo liwości pakietu Swing 391 Zwróćmy uwagę, e w tym przypadku nie implementujemy wcale metod RCKPV%QORQPGPV oraz IGV2TGHGTTGF5KG. Implementacje tych metod posiada bowiem klasa ,.CDGN. Nasze zadanie polega jedynie na skonfigurowaniu tekstu, czcionki i koloru etykiety klasy ,.CDGN zgodnie z naszymi wymaganiami. Klasa (QPV%GNN4GPFGTGT mo e być nawet klasą pochodną klasy ,.CDGN i sama konfiguro- wać swoje parametry w wywołaniu metody IGV.KUV%GNN4GPFGTGT%QORQPGPV, a następnie zwracać wartość VJKU: ENCUU (QPV%GNN4GPFGTGT GZVGPFU ,.CDGN KORNGOGPVU .KUV%GNN4GPFGTGT ] RWDNKE %QORQPGPV IGV.KUV%GNN4GPFGTGT%QORQPGPV ,.KUV NKUV 1DLGEV XCNWG KPV KPFGZ DQQNGCP KU5GNGEVGF DQQNGCP EGNN*CU(QEWU ] (QPV HQPV (QPVXCNWG UGV6GZV HQPVIGV(COKN[ UGV(QPV HQPV UGV1RCSWG VTWG UGV$CEMITQWPF KU5GNGEVGF ! NKUVIGV5GNGEVKQP$CEMITQWPF NKUVIGV$CEMITQWPF UGV(QTGITQWPF KU5GNGEVGF ! NKUVIGV5GNGEVKQP(QTGITQWPF NKUVIGV(QTGITQWPF TGVWTP VJKU _ _ Kod taki stanowi wygodny skrót w sytuacjach, w których istnieje komponent (,.CDGN w na- szym przypadku) o funkcjonalności wystarczającej do narysowania zawartości komórki listy. Listing 6.3. ListRenderingTest.java KORQTV LCXCWVKN
  43. 43. KORQTV LCXCCYV
  44. 44. KORQTV LCXCCYVGXGPV
  45. 45. KORQTV LCXCZUYKPI
  46. 46. KORQTV LCXCZUYKPIGXGPV
  47. 47. 2TQITCO FGOQPUVTWLæE[ Y[MQT[UVCPKG QDKGMVÎY T[UWLæE[EJ MQOÎTMK NKUV[
  48. 48. RWDNKE ENCUU .KUV4GPFGTKPI6GUV ] RWDNKE UVCVKE XQKF OCKP 5VTKPI=? CTIU ] ,(TCOG HTCOG PGY .KUV4GPFGTKPI(TCOG HTCOGUGVGHCWNV%NQUG1RGTCVKQP ,(TCOG':+6A10A%.15' HTCOGUJQY _ _
  49. 49. 4COMC CYKGTCLæEC NKUVú EEKQPGM K RQNG VGMUVQYG MVÎTGIQ VGMUV RQMC[YCP[ LGUV Y[DTCPæ NKUV[ EEKQPMæ
  50. 50. 392 Java 2. Techniki zaawansowane
  51. 51. ENCUU .KUV4GPFGTKPI(TCOG GZVGPFU ,(TCOG ] RWDNKE .KUV4GPFGTKPI(TCOG ] UGV6KVNG .KUV4GPFGTKPI6GUV UGV5KG 9+6* *'+)*6 #TTC[.KUV HQPVU PGY #TTC[.KUV HKPCN KPV 5+' HQPVUCFF PGY (QPV 5GTKH (QPV2.#+0 5+' HQPVUCFF PGY (QPV 5CPU5GTKH (QPV2.#+0 5+' HQPVUCFF PGY (QPV /QPQURCEGF (QPV2.#+0 5+' HQPVUCFF PGY (QPV KCNQI (QPV2.#+0 5+' HQPVUCFF PGY (QPV KCNQI+PRWV (QPV2.#+0 5+' HQPV.KUV PGY ,.KUV HQPVUVQ#TTC[ HQPV.KUVUGV8KUKDNG4QY%QWPV HQPV.KUVUGV5GNGEVKQP/QFG .KUV5GNGEVKQP/QFGN5+0).'A5'.'%6+10 HQPV.KUVUGV%GNN4GPFGTGT PGY (QPV%GNN4GPFGTGT ,5ETQNN2CPG UETQNN2CPG PGY ,5ETQNN2CPG HQPV.KUV ,2CPGN R PGY ,2CPGN RCFF UETQNN2CPG HQPV.KUVCFF.KUV5GNGEVKQP.KUVGPGT PGY .KUV5GNGEVKQP.KUVGPGT ] RWDNKE XQKF XCNWG%JCPIGF .KUV5GNGEVKQP'XGPV GXV ] (QPV HQPV (QPVHQPV.KUVIGV5GNGEVGF8CNWG VGZVUGV(QPV HQPV _ _ %QPVCKPGT EQPVGPV2CPG IGV%QPVGPV2CPG EQPVGPV2CPGCFF R $QTFGT.C[QWV5176* VGZV PGY ,6GZV#TGC 6JG SWKEM DTQYP HQZ LWORU QXGT VJG NC[ FQI VGZVUGV(QPV (QPVHQPVUIGV VGZVUGV.KPG9TCR VTWG VGZVUGV9TCR5V[NG9QTF VTWG EQPVGPV2CPGCFF VGZV $QTFGT.C[QWV%'06'4 _ RTKXCVG ,6GZV#TGC VGZV RTKXCVG ,.KUV HQPV.KUV RTKXCVG UVCVKE HKPCN KPV 9+6* RTKXCVG UVCVKE HKPCN KPV *'+)*6 _
  52. 52. 1DKGMV T[UWLæE[ MQOÎTMK NKUV[ RT[ W [EKW EEKQPMK MVÎTGL PCYú CYKGTC MQOÎTMC
  53. 53. ENCUU (QPV%GNN4GPFGTGT KORNGOGPVU .KUV%GNN4GPFGTGT ]
  54. 54. Rozdział 6. n Zaawansowane mo liwości pakietu Swing 393 RWDNKE %QORQPGPV IGV.KUV%GNN4GPFGTGT%QORQPGPV HKPCN ,.KUV NKUV HKPCN 1DLGEV XCNWG HKPCN KPV KPFGZ HKPCN DQQNGCP KU5GNGEVGF HKPCN DQQNGCP EGNN*CU(QEWU ] TGVWTP PGY ,2CPGN ] RWDNKE XQKF RCKPV%QORQPGPV )TCRJKEU I ] (QPV HQPV (QPVXCNWG 5VTKPI VGZV HQPVIGV(COKN[ (QPV/GVTKEU HO IIGV(QPV/GVTKEU HQPV IUGV%QNQT KU5GNGEVGF ! NKUVIGV5GNGEVKQP$CEMITQWPF NKUVIGV$CEMITQWPF IHKNN4GEV IGV9KFVJ IGV*GKIJV IUGV%QNQT KU5GNGEVGF ! NKUVIGV5GNGEVKQP(QTGITQWPF NKUVIGV(QTGITQWPF IUGV(QPV HQPV IFTCY5VTKPI VGZV HOIGV#UEGPV _ RWDNKE KOGPUKQP IGV2TGHGTTGF5KG ] (QPV HQPV (QPVXCNWG 5VTKPI VGZV HQPVIGV(COKN[ )TCRJKEU I IGV)TCRJKEU (QPV/GVTKEU HO IIGV(QPV/GVTKEU HQPV TGVWTP PGY KOGPUKQP HOUVTKPI9KFVJ VGZV HOIGV*GKIJV _ _ _ _ LCXCZUYKPI,.KUV n %QNQT IGV$CEMITQWPF zwraca kolor tła komórki listy, która nie jest wybrana. n %QNQT IGV5GNGEVKQP$CEMITQWPF zwraca kolor tła komórki listy, która została wybrana. n XQKF UGV%GNN4GPFGTGT .KUV%GNN4GPFGTGT EGNN4GPFGTGT instaluje obiekt wykorzystywany do rysowania zawartości komórek listy. LCXCZUYKPI.KUV%GNN4GPFGTGT n %QORQPGPV IGV.KUV%GNN4GPFGTGT%QORQPGPV ,.KUV NKUV 1DLGEV KVGO KPV KPFGZ DQQNGCP KU5GNGEVGF DQQNGCP JCU(QEWU zwraca komponent, którego metoda RCKPV rysuje zawartość komórek. Jeśli komórki listy nie posiadają stałych rozmiarów, to komponent ten musi tak e implementować metodę IGV2TGHGTTGF5KG.
  55. 55. 394 Java 2. Techniki zaawansowane Parametry: NKUV lista, której komórki mają zostać narysowane, KVGO rysowany element, KPFGZ indeks elementu w modelu, KU5GNGEVGF wartość VTWG, jeśli komórka jest wybrana, JCU(QEWU wartość VTWG, jeśli komórka jest bie ąca. Drzewa Ka dy u ytkownik komputera, którego system operacyjny posiada hierarchicznie zbudo- wany system plików, spotkał się w praktyce z jego reprezentacją za pomocą drzewa, taką jak na przykład na rysunku 6.4. Katalogi i pliki tworzą tylko jedną z wielu mo liwych struktur drzewiastych. Programiści stosują drzewa równie do opisu hierarchii dziedzicze- nia klas. Tak e w yciu codziennym często spotykamy struktury drzewiaste, takie jak hie- rarchie administracyjne państw, stanów, miast itd. (patrz rysunek 6.5). Rysunek 6.4. Drzewo katalogów W programach często trzeba zaprezentować dane w postaci struktury drzewiastej. Biblioteka Swing dostarcza w tym celu klasę ,6TGG. Klasa ,6TGG (wraz z klasami pomocniczymi) słu y do tworzenia reprezentacji graficznej drzewa i przetwarzania akcji u ytkownika polegających na rozwijaniu i zwijaniu węzłów drzewa. W podrozdziale tym nauczymy się korzystać z mo li- wości klasy ,6TGG. Podobnie jak w przypadku innych zło onych komponentów biblioteki Swing, skoncentrujemy się na omówieniu najczęstszych i najbardziej przydatnych przypad- ków zastosowań klasy ,6TGG. Jeśli spotkasz się z nietypowym zastosowaniem drzewa, to po- lecamy ksią kę Core Java Foundation Classes autorstwa Kim Topley (Prentice-Hall, 1998) lub Graphic Java 2 napisaną przez Davida M. Geary’ego (Prentice-Hall, 1999).
  56. 56. Rozdział 6. n Zaawansowane mo liwości pakietu Swing 395 Rysunek 6.5. Hierarchia państw, stanów i miast Zanim przejdziemy do konkretów, warto usystematyzować terminologię związaną z opisem drzew (patrz rysunek 6.6). Drzewo składa się z węzłów. Ka dy węzeł jest albo liściem, albo posiada węzły podrzędne. Ka dy węzeł drzewa z wyjątkiem jego korzenia, posiada dokład- nie jeden węzeł nadrzędny. Ka de drzewo posiada jeden korzeń. Czasami występuje kolek- cja drzew, z których ka de posiada własny korzeń. Nazywamy ją lasem. Rysunek 6.6. Terminologia drzew Najprostsze drzewa Pierwszy przykładowy program wyświetlać będzie drzewo o kilku węzłach (patrz rysunek 6.8). Podobnie jak inne komponenty biblioteki Swing, tak e i klasa ,6TGG jest przykładem zastosowania wzorca model-widok-nadzorca. W praktyce oznacza to, e komponentowi interfejsu u ytkownika musimy dostarczyć model danych. W przypadku klasy ,6TGG będzie to parametr konstruktora: 6TGG/QFGN OQFGN ,6TGG VTGG PGY ,6TGG OQFGN Dostępne są także konstruktory tworzące drzewo na podstawie kolekcji elementów: ,6TGG 1DLGEV=? PQFGU ,6TGG 8GEVQT PQFGU ,6TGG *CUJVCDNG PQFGU YCTVQ EK VCDNKE[ UVCLæ UKú Yú COK FTGYC
  57. 57. 396 Java 2. Techniki zaawansowane Konstruktory te są jednak mało przydatne, gdyż tworzą las drzew, z których każde po- siada jeden węzeł. Ostatni z konstruktorów jest wyjątkowo nieprzydatny, ponieważ wę- zły umieszczane są w drzewie w praktycznie przypadkowy sposób określony przez kody mieszające elementów. Model drzewa tworzymy, definiując klasę implementującą interfejs 6TGG/QFGN. Z mo liwo- ści tej skorzystamy w dalszej części rozdziału, a na początku u yjemy klasy GHCWNV6TG G/QFGN dostarczanej przez bibliotekę Swing. Kreując model tej klasy, musimy dostarczyć mu korzeń. 6TGG0QFG TQQV GHCWNV6TGG/QFGN OQFGN PGY GHCWNV6TGG/QFGN TQQV 6TGG0QFG jest kolejnym z interfejsów związanych z drzewami. Drzewo powstaje z węzłów do- wolnych klas implementujących interfejs 6TGG0QFG. Na razie wykorzystamy w tym celu kon- kretną klasę GHCWNV/WVCDNG6TGG0QFG udostępnianą przez bibliotekę Swing. Klasa ta imple- mentuje interfejs /WVCDNG6TGG0QFG będący specjalizacją interfejsu 6TGG0QFG (patrz rysunek 6.7). Rysunek 6.7. Zależności pomiędzy klasami drzewa Węzeł klasy GHCWNV/WVCDNG6TGG0QFG przechowuje obiekt zwany obiektem u ytkownika. Drzewo rysuje reprezentację obiektów u ytkownika dla wszystkich węzłów. Dopóki nie zostanie zainstalowany specjalizowany obiekt rysujący węzły, to drzewo wyświetla po pro- stu łańcuch znaków będący wynikiem wywołania metody VQ5VTKPI. Nasz pierwszy przykład wykorzystywać będzie łańcuchy znaków jako obiekty u ytkowni- ka. W praktyce drzewo tworzą zwykle bardziej zło one obiekty, na przykład drzewo repre- zentujące system plików składać się mo e z obiektów klasy (KNG. Obiekt u ytkownika mo emy przekazać jako parametr konstruktora węzła bądź później za pomocą metody UGV7UGT1DLGEV. GHCWNV/WVCDNG6TGG0QFG PQFG PGY GHCWNV/WVCDNG6TGG0QFG 6GZCU PQFGUGV7UGT1DLGEV %CNKHQTPKC
  58. 58. Rozdział 6. n Zaawansowane mo liwości pakietu Swing 397 Następnie musimy utworzyć powiązania pomiędzy węzłami nadrzędnymi i podrzędnymi. Konstrukcję drzewa rozpoczniemy od korzenia, a później dodamy do niego węzły podrzędne: GHCWNV/WVCDNG6TGG0QFG TQQV PGY GHCWNV/WVCDNG6TGG0QFG 9QTNF GHCWNV/WVCDNG6TGG0QFG EQWPVT[ PGY GHCWNV/WVCDNG6TGG0QFG 75# TQQVCFF EQWPVT[ GHCWNV/WVCDNG6TGG0QFG UVCVG PGY GHCWNV/WVCDNG6TGG0QFG %CNKHQTPKC EQWPVT[CFF UVCVG Rysunek 6.8 pokazuje drzewo utworzone przez program. Rysunek 6.8. Najprostsze drzewo Po skonstruowaniu i połączeniu wszystkich węzłów mo emy utworzyć model drzewa, prze- kazując mu korzeń, a następnie wykorzystać model do opracowania komponentu ,6TGG. GHCWNV6TGG/QFGN VTGG/QFGN PGY GHCWNV6TGG/QFGN TQQV ,6TGG PGY ,6TGG VTGG/QFGN Mo emy nawet przekazać korzeń bezpośrednio konstruktorowi klasy ,6TGG, który w takim przypadku sam utworzy model drzewa: ,6TGG PGY ,6TGG TQQV Listing 6.4 zawiera kompletny tekst źródłowy programu. Listing 6.4. SimpleTree.java KORQTV LCXCCYV
  59. 59. KORQTV LCXCCYVGXGPV
  60. 60. KORQTV LCXCZUYKPI
  61. 61. KORQTV LCXCZUYKPIVTGG
  62. 62. 2TQITCO Y[ YKGVNCLæE[ PCLRTQUVUG FTGYQ
  63. 63. RWDNKE ENCUU 5KORNG6TGG ] RWDNKE UVCVKE XQKF OCKP 5VTKPI=? CTIU ] ,(TCOG HTCOG PGY 5KORNG6TGG(TCOG HTCOGUGVGHCWNV%NQUG1RGTCVKQP ,(TCOG':+6A10A%.15' HTCOGUJQY _ _
  64. 64. 398 Java 2. Techniki zaawansowane
  65. 65. 4COMC CYKGTCLæEC FTGYQ Y[ YKGVNCLæEG FCPG WOKGUEQPG RTG RTQITCO Y OQFGNW
  66. 66. ENCUU 5KORNG6TGG(TCOG GZVGPFU ,(TCOG ] RWDNKE 5KORNG6TGG(TCOG ] UGV6KVNG 5KORNG6TGG UGV5KG 9+6* *'+)*6 DWFWLG OQFGN FTGYC GHCWNV/WVCDNG6TGG0QFG TQQV PGY GHCWNV/WVCDNG6TGG0QFG 9QTNF GHCWNV/WVCDNG6TGG0QFG EQWPVT[ PGY GHCWNV/WVCDNG6TGG0QFG 75# TQQVCFF EQWPVT[ GHCWNV/WVCDNG6TGG0QFG UVCVG PGY GHCWNV/WVCDNG6TGG0QFG %CNKHQTPKC EQWPVT[CFF UVCVG GHCWNV/WVCDNG6TGG0QFG EKV[ PGY GHCWNV/WVCDNG6TGG0QFG 5CP ,QUG UVCVGCFF EKV[ EKV[ PGY GHCWNV/WVCDNG6TGG0QFG %WRGTVKPQ UVCVGCFF EKV[ UVCVG PGY GHCWNV/WVCDNG6TGG0QFG /KEJKICP EQWPVT[CFF UVCVG EKV[ PGY GHCWNV/WVCDNG6TGG0QFG #PP #TDQT UVCVGCFF EKV[ EQWPVT[ PGY GHCWNV/WVCDNG6TGG0QFG )GTOCP[ TQQVCFF EQWPVT[ UVCVG PGY GHCWNV/WVCDNG6TGG0QFG 5EJNGUYKI*QNUVGKP EQWPVT[CFF UVCVG EKV[ PGY GHCWNV/WVCDNG6TGG0QFG -KGN UVCVGCFF EKV[ VYQT[ FTGYQ K WOKGUEC LG Y RTGYKLCNP[O RCPGNW ,6TGG VTGG PGY ,6TGG TQQV %QPVCKPGT EQPVGPV2CPG IGV%QPVGPV2CPG EQPVGPV2CPGCFF PGY ,5ETQNN2CPG VTGG _ RTKXCVG UVCVKE HKPCN KPV 9+6* RTKXCVG UVCVKE HKPCN KPV *'+)*6 _ Po uruchomieniu programu powstanie drzewo, które zobaczymy na rysunku 6.9. Widoczny będzie jedynie korzeń drzewa oraz jego węzły podrzędne. Wybranie myszą uchwytu węzła spowoduje rozwinięcie poddrzewa. Odcinki wystające z ikony uchwytu węzła skierowane są w prawo, gdy poddrzewo jest zwinięte i w dół w przeciwnym razie (patrz rysunek 6.10). Nie wiemy, co mieli na myśli projektanci wyglądu interfejsu zwanego Metal, tworząc ikonę uchwytu węzła, ale nam przypomina ona w działaniu klamkę drzwi. Kierujemy ją w dół, aby rozwinąć poddrzewo.
  67. 67. Rozdział 6. n Zaawansowane mo liwości pakietu Swing 399 Rysunek 6.9. Początkowy wygląd drzewa Rysunek 6.10. Zwinięte i rozwinięte poddrzewa Wygląd drzewa zależy od wybranego wyglądu komponentów interfejsu użytkownika. Opisując dotąd drzewo, korzystaliśmy ze standardowego dla aplikacji Java wyglądu in- terfejsu Metal. W przypadku interfejsów Motif lub Windows uchwyty węzłów posiadają postać kwadratów zawierających znaki plus lub minus (patrz rysunek 6.11). Rysunek 6.11. Drzewo o wyglądzie Windows Do wersji SDK 1.3 włącznie linie łączące węzły drzewa domyślnie nie były rysowane (patrz rysunek 6.12). Począwszy od SKD 1.4, rysowane są domyślnie. Rysunek 6.12. Drzewo bez linii łączących węzły Korzystając z SDK 1.4., mo emy wyłączyć rysowanie linii łączących węzły: VTGGRWV%NKGPV2TQRGTV[ ,6TGGNKPG5V[NG 0QPG
  68. 68. 400 Java 2. Techniki zaawansowane lub włączyć je z powrotem: VTGGRWV%NKGPV2TQRGTV[ ,6TGGNKPG5V[NG #PINGF Istnieje tak e styl linii *QTKQPVCN pokazany na rysunku 6.13. Poziome linie oddzielają wtedy węzły podrzędne korzenia. Nie jesteśmy przekonani o celowości takiego rozwiązania. Rysunek 6.13. Drzewo wykorzystujące styl linii Horizontal Domyślnie korzeń drzewa nie posiada uchwytu, który umo liwiałby zwinięcie całego drzewa. Mo emy go dodać następująco: VTGGUGV5JQYU4QQV*CPFNGU VTWG Rysunek 6.14 pokazuje rezultat. Mo emy teraz zwinąć całe drzewo do korzenia. Rysunek 6.14. Drzewo posiadające uchwyt korzenia Mo emy tak e w ogóle usunąć reprezentację korzenia drzewa, uzyskując w ten sposób las drzew, z których ka de posiada własny korzeń. Tworząc taki las, nadal musimy jednak po- łączyć wszystkie drzewa wspólnym korzeniem, który następnie ukrywamy, wywołując VTGGUGV4QQV8KUKDNG HCNUG Efekt przedstawia rysunek 6.15. Występują na nim dwa korzenie oznaczone „USA” i „Ger- many”. W rzeczywistości są to węzły posiadające wspólny, ukryty korzeń. Rysunek 6.15. Las Zajmijmy się teraz liśćmi drzewa. Zwróćmy uwagę, e ikony liści ró nią się od ikon pozo- stałych węzłów drzewa (patrz rysunek 6.16).
  69. 69. Rozdział 6. n Zaawansowane mo liwości pakietu Swing 401 Rysunek 6.16. Ikony liści Ka dy węzeł drzewa reprezentowany jest za pomocą pewnej ikony. Wyró nić mo na trzy rodzaje takich ikon: ikona liścia, ikona węzła, którego poddrzewo jest rozwinięte i ikona węzła, którego poddrzewo jest zwinięte. Dla uproszczenia dwa ostatnie rodzaje ikon bę- dziemy nazywać wspólnie ikonami folderu. Obiekt rysujący węzły drzewa musi otrzymać informację, jakiej ikony powinien u yć dla da- nego węzła. Domyślny proces decyzyjny przebiega następująco: jeśli metoda KU.GCH zwraca wartość VTWG, to rysowana jest ikona liścia. W przeciwnym razie u ywana jest ikona folderu. Metoda KU.GCH klasy GHCWNV/WVCDNG6TGG0QFG zwraca wartość VTWG dla ka dego węzła, któ- ry nie posiada węzłów podrzędnych. W ten sposób węzły posiadające węzły podrzędne otrzymują ikonę folderu, a pozostałe węzły — ikonę liścia. Czasami rozwiązanie takie nie jest jednak właściwe. Załó my, e do naszego drzewa doda- liśmy węzeł reprezentujący stan Montana i dopiero zastanawiamy się, jakie miasta powin- niśmy umieścić jako jego węzły podrzędne. Nie chcemy przy tym, aby węzeł reprezentują- cy stan posiadał ikonę liścia, poniewa koncepcyjnie przysługuje ona tylko miastom. Klasa ,6TGG nie wie, które węzły powinny być liśćmi. Decyduje o tym model drzewa. Jeśli węzeł, który nie posiada węzłów podrzędnych, nie jest liściem z punktu widzenia koncepcji drzewa, to model drzewa mo e zastosować inne kryterium rozpoznawania liści. Polega ono na wykorzystaniu właściwości węzła zezwalającej na posiadanie węzłów podrzędnych. Dla węzłów, które nie będą posiadać węzłów podrzędnych, nale y wtedy wywołać: PQFGUGV#NNQYU%JKNFTGP HCNUG oraz poinformować model drzewa, by, decydując czy danym węzeł jest liściem, sprawdzał, czy mo e on posiadać węzły podrzędne. W tym celu wywołujemy metodę UGV#UMU#NNQYU %JKNFTGP klasy GHCWNV6TGG/QFGN: OQFGN UGV#UMU#NNQYU%JKNFTGP VTWG Od tego momentu węzły, które mogą posiadać węzły podrzędne, otrzymują ikonę folderu, a pozostałe ikonę liścia. Takie kryterium doboru ikony mo emy tak e uzyskać, tworząc obiekt klasy ,6TGG za po- mocą odpowiedniego konstruktora: ,6TGG VTGG PGY ,6TGG TQQV VTWG Yú [ MVÎTG PKG OQIæ RQUKCFCè Yú ÎY RQFTúFP[EJ QVT[OCLæ KMQPú NK EKC
  70. 70. 402 Java 2. Techniki zaawansowane LCXCZUYKPI,6TGG n ,6TGG 6TGG/QFGN OQFGN tworzy drzewo na podstawie modelu. n ,6TGG 6TGG0QFG TQQV n ,6TGG 6TGG0QFG TQQV DQQNGCP CUMU#NNQY%JKNFTGP Tworzą drzewo, korzystając z domyślnego modelu i wyświetlając początkowo korzeń i jego węzły podrzędne. Parametry: TQQV korzeń, CUMU#NNQY%JKNFTGP, jeśli posiada wartość VTWG, to węzeł jest liściem, gdy mo e posiadać węzły podrzędne. n XQKF UGV5JQYU4QQV*CPFNGU DQQNGCP D, jeśli D posiada wartość VTWG, to korzeń posiada uchwyt umo liwiający zwinięcie drzewa. n XQKF UGV4QQV8KUKDNG DQQNGCP D, jeśli D posiada wartość VTWG, to korzeń jest wyświetlany. W przeciwnym razie jest ukryty. LCXCZUYKPIVTGG6TGG0QFG n DQQNGCP KU.GCH zwraca wartość VTWG, jeśli dany węzeł reprezentuje liść na poziomie koncepcji. n DQQNGCP IGV#NNQYU%JKNFTGP zwraca wartość VTWG, jeśli dany węzeł mo e posiadać węzły podrzędne. LCXCZUYKPIVTGG/WVCDNG6TGG0QFG n XQKF UGV7UGT1DLGEV 1DLGEV WUGT1DLGEV określa obiekt u ytkownika dla danego węzła. LCXCZUYKPIVTGG6TGG/QFGN n DQQNGCP KU.GCH 1DLGEV PQFG zwraca wartość VTWG, jeśli węzeł PQFG zostanie wyświetlony jako liść. LCXCZUYKPIVTGGGHCWNV6TGG/QFGN n XQKF UGV#UMU#NNQYU%JKNFTGP DQQNGCP D, jeśli D posiada wartość VTWG, to węzły wyświetlane są jako liście, w przypadku gdy metoda IGV#NNQYU%JKNFTGP zwraca wartość HCNUG. Gdy D posiada wartość HCNUG, to węzły wyświetlane są jako liście, jeśli metoda KU.GCH zwraca wartość VTWG. LCXCZUYKPIVTGGGHCWNV/WVCDNG6TGG0QFG n GHCWNV/WVCDNG6TGG0QFG 1DLGEV WUGT1DLGEV tworzy węzeł drzewa zawierający podany obiekt u ytkownika.
  71. 71. Rozdział 6. n Zaawansowane mo liwości pakietu Swing 403 n XQKF CFF /WVCDNG6TGG0QFG EJKNF dodaje do węzła węzeł podrzędny. n XQKF UGV#NNQYU%JKQNFTGP DQQNGCP D, jeśli D posiada wartość VTWG, to do węzła mogą być dodawane węzły podrzędne. LCXCZUYKPI,%QORQPGPV n XQKF RWV%NKGPV2TQRGTV[ 1DLGEV MG[ 1DLGEV XCNWG dodaje parę MG[XCNWG do niewielkiej tablicy, którą zarządza ka dy komponent. Mechanizm ten jest stosowany przez niektóre komponenty Swing w celu przechowywania specyficznych właściwości związanych z wyglądem komponentu. Modyfikacje drzew i ście ki drzew Następny przykład programu ilustrować będzie sposób modyfikacji drzew. Rysunek 6.17 przedstawia potrzebny interfejs u ytkownika. Jeśli wybierzemy przycisk Add Sibling lub Add Child, to program doda do drzewa nowy węzeł opisany jako New. Jeśli wybierzemy przycisk Delete, to usuniemy wybrany węzeł. Rysunek 6.17. Modyfikowanie drzewa Aby zaimplementować takie zachowanie, musimy uzyskać informację o tym, który z wę- złów drzewa jest aktualnie wybrany. Klasa ,6TGG zaskoczy nas z pewnością sposobem identyfikacji węzłów w drzewie. Wykorzystuje ona ście ki do obiektów nazywane ście ka- mi drzewa. Ście ka taka zaczyna się zawsze od korzenia i zawiera sekwencje węzłów pod- rzędnych (patrz rysunek 6.18). Rysunek 6.18. Ścieżka drzewa Zastanawiać mo e, w jakim celu klasa ,6TGG potrzebuje całej ście ki. Czy nie wystarczyłby jej obiekt klasy 6TGG0QFG i mo liwość wywołania metody IGV2CTGPV? Okazuje się, e klasa ,6TGG nie ma pojęcia o istnieniu interfejsu 6TGG0QFG. Nie jest on wykorzystywany przez in- terfejs 6TGG/QFGN, a dopiero przez implementującą go klasę GHCWNV6TGG/QFGN. Mo emy tworzyć te inne modele drzewa, które nie będą wykorzystywać interfejsu 6TGG0QFG. Więc

×