Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00107 007799 10476346 na godz. na dobę w sumie
JBuilder X. Efektywne programowanie w Javie - książka
JBuilder X. Efektywne programowanie w Javie - książka
Autor: Liczba stron: 384
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-293-9 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook, audiobook).

Jeśli wierzyć prognozom firmy Borland -- producenta JBuildera -- pod koniec obecnego dziesięciolecia prawie 80% aplikacji będzie tworzonych w Javie i bazujących na niej środowiskach. Rozmaite dziedziny ludzkiej działalności stawiają przed informatyką coraz to większe wymagania. Coraz cenniejszym zasobem staje się inwencja i produktywność projektantów-programistów, którym trzeba w jak największym stopniu umożliwić twórcze działanie. Warto ich odciążyć od drugorzędnych zadań, które z powodzeniem można powierzyć coraz lepszym i coraz tańszym maszynom. Obecnie, w dobie upowszechnienia się komputerów osobistych, trudno wyobrazić sobie profesjonalne tworzenie aplikacji bez usprawniających to przedsięwzięcie nowoczesnych narzędzi (RAD), z JBuilderem na czele. Warto pamiętać, że firma Borland jest producentem dwóch innych narzędzi RAD, które zrewolucjonizowały proces tworzenia aplikacji: Delphi i C++Buildera -- kolejne wersje tych produktów obecne są na rynku od niemal dziesięciu lat.

Niniejsza książka stanowi praktyczny podręcznik zarówno dla początkujących, którzy na gruncie JBuildera zamierzają zdobywać swe pierwsze doświadczenia programistyczne, jak i tych, którzy w swojej pracy używają Delphi i C++Buildera, a w JBuilderze szukają interesującej alternatywy.

W książce omówiono między innymi:

Nie trać czasu na coś, w czym może Cię wyręczyć komputer,
zajmij się projektowaniem apletów i aplikacji.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl JBuilder X. Efektywne programowanie w Javie Autor: Jacek Matulewski ISBN: 83-7361-293-9 Format: B5, stron: 384 Jeġli wierzyæ prognozom firmy Borland — producenta JBuildera — pod koniec obecnego dziesiêciolecia prawie 80 aplikacji bêdzie tworzonych w Javie i bazuj¹cych na niej ġrodowiskach. Rozmaite dziedziny ludzkiej dzia³alnoġci stawiaj¹ przed informatyk¹ coraz to wiêksze wymagania. Coraz cenniejszym zasobem staje siê inwencja i produktywnoġæ projektantów-programistów, którym trzeba w jak najwiêkszym stopniu umo¿liwiæ twórcze dzia³anie. Warto ich odci¹¿yæ od drugorzêdnych zadañ, które z powodzeniem mo¿na powierzyæ coraz lepszym i coraz tañszym maszynom. Obecnie, w dobie upowszechnienia siê komputerów osobistych, trudno wyobraziæ sobie profesjonalne tworzenie aplikacji bez usprawniaj¹cych to przedsiêwziêcie nowoczesnych narzêdzi (RAD), z JBuilderem na czele. Warto pamiêtaæ, ¿e firma Borland jest producentem dwóch innych narzêdzi RAD, które zrewolucjonizowa³y proces tworzenia aplikacji: Delphi i C++Buildera —- kolejne wersje tych produktów obecne s¹ na rynku od niemal dziesiêciu lat. Niniejsza ksi¹¿ka stanowi praktyczny podrêcznik zarówno dla pocz¹tkuj¹cych, którzy na gruncie JBuildera zamierzaj¹ zdobywaæ swe pierwsze doġwiadczenia programistyczne, jak i tych, którzy w swojej pracy u¿ywaj¹ Delphi i C++Buildera, a w JBuilderze szukaj¹ interesuj¹cej alternatywy. W ksi¹¿ce omówiono miêdzy innymi: • Podstawy jêzyka Java i bogate mechanizmy ġrodowiska zintegrowanego JBuildera X • Korzystanie z nowoczesnych technik programistycznych oraz narzêdzi i mechanizmów wspomagaj¹cych tworzenie aplikacji i apletów • Stosowanie bibliotek i szablonów oraz JavaBeans • Bazodanowe zastosowania JBuildera X, mechanizmy JDataStore, JDBC i ODBC • Tworzenie i u¿ywanie archiwów JAR • Modelowanie i projektowanie komponentów • Dokumentowanie procesu projektowego za pomoc¹ JavaDoc Nie traæ czasu na coġ, w czym mo¿e Ciê wyrêczyæ komputer; zajmij siê projektowaniem apletów i aplikacji. Spis treści Wstęp ...................................................z............................................ 9 Rozdział 1. Pierwsze spotkanie z JBuilderem ...................................................z... 11 Trivia ................................................... ................................................... ...........................11 Co to jest JBuilder? ................................................... ..................................................11 Nie tylko JBuilder ................................................... ................................................... .12 Co nowego w darmowej edycji JBuilder X Foundation? ...........................................13 Zintegrowane środowisko programistyczne................................................... ...................14 Przewodnik po oknach i zakładkach IDE ................................................... ................14 Jak bezboleśnie przesiąść się z Delphi lub C++ Buildera do JBuildera? ...................17 Pomoc ................................................... ................................................... ...................18 Konfigurowanie edytora i innych elementów środowiska programisty .....................19 Tworzenie i zarządzanie projektem................................................... ................................25 Ustawienia formatowania kodu źródłowego ................................................... ...........29 JBuilder w służbie programisty, czyli przez Javę na skróty .............................................30 Kreator apletu. Pierwszy aplet „Hello World!” ................................................... .......30 Aby obejrzeć aplet w zewnętrznej przeglądarce…................................................... ..37 Analiza kodu pierwszego apletu ................................................... ..............................40 Osadzanie apletu w dokumencie HTML ................................................... .................43 Kontrola działania apletu przez przeglądarkę................................................... ..........44 CodeInsight — budka suflera ................................................... ..................................47 Parametry odbierane z dokumentu HTML ................................................... ..............48 Kontrola działania apletu poprzez komponenty sterujące i ich metody zdarzeniowe....52 Jak skasować niepotrzebną metodę zdarzeniową? ................................................... ..59 Modyfikacja konfiguracji uruchamiania ................................................... ........................59 Kilka słów o debugowaniu................................................... .............................................63 Rozdział 2. Java ...................................................z............................................. 71 Kilka słów wstępu ................................................... ................................................... .......71 Nowe i „stare” cechy Javy ................................................... .......................................71 Wirtualna maszyna Javy. Przenośność ................................................... ....................72 Czy można za pomocą JBuildera…? ................................................... .......................73 Język................................................... ................................................... ............................73 Komentarze ................................................... ................................................... ...........74 Konwencja wielkości liter................................................... ........................................74 Proste typy danych ................................................... ................................................... 75 Łańcuchy................................................... ................................................... ...............77 Tablice................................................... ................................................... ...................79 Instrukcje sterujące ................................................... ..................................................81 6 JBuilder X. Efektywne programowanie w Javie Klasy i obiekty ................................................... ................................................... ............96 Nie warto unikać klas i obiektów! ................................................... ...........................96 Projektowanie klasy ................................................... .................................................97 Kilka dodatkowych wiadomości o klasach w skrócie ..............................................130 Rozdział 3. Przykładowe aplety i aplikacje...................................................z..... 135 Kolejne przykłady wykorzystania biblioteki AWT do projekto wania RAD w JBuilderze ................................................... ................................................... ...........136 Aplet Scrollbars ................................................... ................................................... ..136 Tworzenie apletu będącego równocześnie aplikacją. Pobieranie informacji o wirtualnej maszynie Javy ................................................... .................................144 Biblioteka Swing (Java 2) ................................................... ............................................155 Swing kontra AWT ................................................... ................................................155 Pierwsza aplikacja Swing — Notatnik ................................................... ..................156 Aplikacja JPictureView — obrazy, ikony i pasek narzędzi......................................186 Rozdział 4. Praca z kodem. Szablony...................................................z............. 199 Korzystanie z szablonów podczas „ręcznego” projektowania interfejsu. Aplet Puzzle.....199 Projektowanie RAD interfejsu vs. wykorzystanie tablic komponentów ..................199 Menedżer położenia komponentów ................................................... .......................200 Ręczne przygotowanie interfejsu apletu. Tablice obiektów .....................................205 „Prawie ręczne” tworzenie metod zdarzeniowych i nasłuchiwaczy.........................208 Metoda zdarzeniowa ................................................... ..............................................211 Odmierzanie czasu w osobnym wątku. Tworzenie szablonów. Układanie puzzli na czas. ...219 Rozdział 5. Aplikacje konsolowe w JBuilderze .................................................. 227 Rozdział 6. Komponenty JavaBean od środka ...................................................z 231 Tworzenie komponentów JavaBean................................................... .............................231 Klasa MigajacyPrzycisk i środowisko do jej testowania ..........................................232 Wykorzystanie interfejsu Runnable ................................................... .......................237 Właściwości komponentów ................................................... ...................................243 Definiowanie dodatkowych zdarzeń................................................... ......................247 Instalowanie komponentu na palecie komponentów JBuildera ......................................254 Klasa typu BeanInfo towarzysząca komponentowi ................................................... .....258 BeansExpress ................................................... ................................................... ............261 Właściwości ................................................... ................................................... ........263 Zdarzenia................................................... ................................................... .............266 Edytor właściwości i BeanInfo ................................................... ..............................267 Diagram UML komponentu................................................... ...................................270 Silnik komponentu (metoda run) ................................................... ...........................271 Inicjacja komponentu................................................... .............................................273 Testowanie komponentu ................................................... ........................................274 Rozdział 7. Dystrybucja apletów, aplikacji i ziarenek JavaBean ......................... 277 Które pliki przenieść na serwer WWW, aby aplet działał? Jakie pliki należy dołączyć do aplikacji, aby ją uruchomić na innym komputerze?......................278 Rozpoznawanie plików skompilowanych klas ................................................... ......278 Tworzenie skryptów, plików wsadowych i skrótów.................................................279 „Izolowanie” klas aplikacji ................................................... ....................................282 Pliki JAR. Archive Builder ................................................... ..........................................282 Umieszczanie aplikacji w archiwach JAR ................................................... .............283 Umieszczanie apletów w archiwach JAR ................................................... ..............289 Komponenty JavaBean w archiwach JAR ................................................... .............290 Spis treści 7 Tworzenie pliku uruchamialnego................................................... .................................294 Tworzenie dokumentacji ................................................... ..............................................296 Tworzenie dokumentacji za pomocą javadoc z JDK ................................................297 Kreator Javadoc ................................................... ................................................... ..300 Rozdział 8. Bazy danych w JBuilderze...................................................z............ 305 Kilka słów wprowadzenia ................................................... ............................................305 Podstawowe pojęcia związane z bazami danych ................................................... ...306 Czy znajomość SQL jest niezbędna? ................................................... .....................306 Lokalne bazy danych. JDBC i ODBC................................................... ..........................307 Konfigurowanie DSN dla bazy danych ODBC (Windows) .....................................308 Tworzenie modułu danych za pomocą Data Modeler. Składnia p olecenia SELECT języka SQL. ................................................... .........................................309 Tworzenie aplikacji bazodanowych................................................... .......................315 Komponenty dbSwing ................................................... ...........................................318 Samodzielne konfigurowanie połączenia ................................................... ..............323 Master/Detail................................................... ................................................... .......325 Database Pilot ................................................... ................................................... .....329 JDataStore. W kierunku baz danych typu klient-serwer .................................................330 JDataStore Explorer ................................................... ...............................................330 Tworzenie modułu danych................................................... .....................................335 Aplikacje korzystające z bazy danych JDataStore................................................... .337 Zdalne bazy danych i JDataStore Server ................................................... ...............346 Dodatek A Kompilacja i archiwizowanie narzędziami JDK bez JBuildera............. 351 Kompilacja ................................................... ................................................... ................351 Tworzenie archiwów JAR................................................... ............................................353 Dodatek B Co zabawnego można zrobić z obrazem? ......................................... 355 Konwersja na tablicę pikseli i jej modyfikowanie na przykładzie negatywu .................355 Konwersja obrazu na tablicę pikseli opisywanych typem int ...................................356 Składowe A, R, G i B każdego piksela. Operacje na bitach. Negatyw ....................357 Konwersja tablicy pikseli do obiektu typu Image................................................... ..360 Implementacja w JPictureView................................................... ....................................360 Trochę zabawy: konwersja obrazu do ASCII Art. ................................................... .......362 Skorowidz ...................................................z.................................. 365 Rozdział 6. Komponenty JavaBean od środka Wykorzystamy teraz wiedzę i praktyczne umiejętności na temat Javy i JBuildera zdo- byte w poprzednich rozdziałach do stworzenia komponentu JavaBean1. Ziarenko, które przygotujemy, będzie cyklicznie zmieniało kolory, czyli mówiąc prościej — będzie migającym przyciskiem. Tak zresztą nazwiemy nasz kompomnent — /KICLCE[2T[EKUM. Niestety, będziemy musieli w dużym stopniu przygotować ten komponent „ręcznie”. O ile w wersji komercyjnej JBuilder zawiera narzędzia $GCPU ZRTGUU i $GCP+PUKIJV, które wydatnie wspomagają tworzenie ziarenek JavaBean, to w wersji darmowej JBuildera działają one tylko przez 30 dni od instalacji. Mimo to, także w JBuilder Foundation, istnieje możliwość względnie szybkiego przygotowania komponentu JavaBean, o czym postaram się Czytelnika przekonać w mćwiczeniach z tego rozdziału. W pierwszej części rozdziału przedstawię podstawowe informacje o projektowaniu komponentów w JBuilder Foundation, w tym o definiowaniu ich nowych właściwości i zdarzeń. Następnie omówię procedurę instalacji komponentów w JBuilderze, a na końcu sposób przygotowania klasy typu $GCP+PHQ. Najwłaściwszą formą dystrybucji komponentu jest archiwum JAR. Jak je tworzyć, dowiemy się w rozdziale 7. Tworzenie komponentów JavaBean Zaprojektujemy klasę /KICLCE[2T[EKUM, która będzie prostym przykładem kompo- nentu JavaBean. /KICLCE[2T[EKUM zbudujemy na bazie komponentu LCXCCYV$WVVQP z biblioteki AWT. Jego działanie nie będzie skomplikowane — będzie to po prostu 1 Bean w języku angielskim oznacza ziarno, ziarenko. W konfeinowej poetyce Javy chodzi najpewniej o ziarenko kawy. 232 JBuilder X. Efektywne programowanie w Javie przycisk, w którym cyklicznie zamieniane są kolory tła i napisu. Klasę $WVVQP rozsze- rzymy o nowe właściwości QMTGU, QRQPKGPKG oraz OKICPKG9NCEQPG umożliwiające kontrolę migania przycisku. Klasa MigajacyPrzycisk i środowisko do jej testowania Podczas projektowania komponentu wygodnie jest mieć aplet, w którym możemy go od razu testować. Dlatego zaczniemy od zdefiniowania dwóch klas, klasy komponentu /KICLCE[2T[EKUM oraz klasy apletu /KICLCE[2T[EKUM GOQ. Ćwiczenie 6.1. Aby stworzyć klasę o nazwie /KICLCE[2T[EKUM rozszerzającą klasę LCXCCYV$WVVQP: 1. Z menu File wybieramy pozycję New Class…. 2. W kreatorze klasy (rysunek 6.1) podajemy: a) nazwę pakietu (pole Package) JGNKQPT b) PCYúMNCU[ RQNGClass name /KICLCE[2T[EKUM oraz c) klasę bazową (Base class) LCXCCYV$WVVQP. Rysunek 6.1. Rozszerzanie klasy java.awt.Button 3. W kreatorze klasy zaznaczamy: a) opcję Override superclass constructor, oznaczającą, że w wygenerowanym przez JBuildera kodzie nadpisane zostaną wszystkie konstrmuktory klasy bazowej, oraz b) opcję Public, ponieważ klasa komponentu JavaBean musi być oczywimście publiczna. 4. Naciskamy OK. Rozdział 6. ♦ Komponenty JavaBean od środka 233 Po zamknięciu kreatora uzyskujemy następujący kod zaprezentowany na listingu 6.1. Ze względu na opcję zaznaczoną w punkcie 3a ćwiczenia w klasie zadeklarowane zostały dwa konstruktory obecne również w klasie bazowej: konstruktor domyślny oraz konstruktor przyjmujący jako argument treść etykmiety na przycisku. Listing 6.1. Stworzona przez kreator klasa MigajacyPrzycisk (poimijam komentarz nagłówkowy) RCEMCIGJGNKQPT KORQTVLCXCCYV$WVVQP KORQTVLCXCCYV*GCFNGUU ZEGRVKQP RWDNKEENCUU/KICLCE[2T[EKUMGZVGPFU$WVVQP ] RWDNKE/KICLCE[2T[EKUM VJTQYU*GCFNGUU ZEGRVKQP ] _ RWDNKE/KICLCE[2T[EKUM 5VTKPINCDGN VJTQYU*GCFNGUKU ZEGRVKQP ] UWRGT NCDGN  _ _ Ćwiczenie 6.2. Aby stworzyć aplet /KICLCE[2T[EKUM GOQ, który będzie służył do testowania klasy /KICLCE[2T[EKUM: 1. Uruchamiamy kreator apletu, a więc z menu File wybieramy pozycję New, w otwartym oknie Object Gallery przechodzimy na zakładkę Web i klikamy ikonę Applet. Naciskamy OK. 2. W kreatorze apletu (rysunek 6.2) wpisujemy: a) w polu Class name nazwę klasy apletu /KICLCE[2T[EKUM GOQ, b) w polu Package nazwę pakietu JGNKQPT, c) w polu Base class klasę bazową LCXCCRRNGV#RRNGV. 3. Zaznaczamy opcję Generate standard methods, aby JBuilder w kodzie apletu umieścił metody standardowe UVCTV, UVQR i FGUVTQ[. 4. W ostatnim kroku kreatora zaznaczamy opcję tworzenima konfiguracji uruchamiania. 5. W komercyjnych wersjach JBuildera zmieniamy domyślnmą konfigurację uruchamiania na MigajacyPrzyciskDemo (zobacz ćwiczenie 1.18). Efektem wykonania tego ćwiczenia jest dodanie do pakietu JGNKQPT klasy apletu /KICLCE[2T[EKUM GOQ, która posłuży nam jako środowisko testowania komponentu. Ponieważ klasa /KICLCE[2T[EKUM należy do tego samego pakietu, będzie widoczna z apletu bez potrzeby importowania. 234 Rysunek 6.2. Kreator apletu JBuilder X. Efektywne programowanie w Javie Ćwiczenie 6.3 Aby w aplecie /KICLCE[2T[EKUM GOQ zdefiniować dwa obiekty typu /KICLCE[2T[EKUM: 1. Dodajemy w obrębie klasy apletu dwie linie wyróżnionem na poniższym listingu. Listing 6.2. W klasie apletu deklarujemy dwa obiekty typu MigajacyiPrzycisk RWDNKEENCUU/KICLCE[2T[EKUM GOQGZVGPFU#RRNGV ] RTKXCVGDQQNGCPKU5VCPFCNQPGHCNUG /KICLCE[2T[EKUMORPGY/KICLCE[2T[EKUM  /KICLCE[2T[EKUMORPGY/KICLCE[2T[EKUM *GNKQPT   CNUCEúħèMNCU[CRNGVW Do stworzenia pierwszego obiektu wykorzystaliśmy domyślny konstruktor, a drugiego — konstruktor pozwalający ustalić etykietę przycisku.m Ćwiczenie 6.4. Aby zdefiniowane w poprzednim ćwiczeniu przyciski umieścić na powierzchni apletu: 1. Umieszczamy w metodzie LD+PKV apletu wywołanie metody VJKUCFF dla każdego z przycisków: RTKXCVGXQKFLD+PKV VJTQYU ZEGRVKQP ] VJKUCFF OR  VJKUCFF OR  _ 2. Naciskamy klawisz Ctrl+F9, aby skompilować klasę /KICLCE[2T[EKUM i aplet /KICLCE[2T[EKUM GOQ. Rozdział 6. ♦ Komponenty JavaBean od środka 235 3. Naciskamy klawisz F12, aby przenieść się na zakładkę Design i obejrzeć podgląd apletu z przyciskami. Z punktu widzenia Javy nie ma znaczenia, czy polecenia z punktu pierwszego umie- ścimy w metodzie KPKV, czy w wywoływanej z niej LD+PKV — po uruchomieniu apletu wynik będzie identyczny. Należy jednak pamiętać, że do przygotowania podglądu na zakładce Desing JBuilder analizuje tylko tę drugą metodę. Warunkiem uzyskania prawidłowego podglądu apletu z umieszczonymi na nim przy- ciskami jest kompilacja komponentu do postaci pliku MigajacyPrzycisk.class (drugi punkt). Jeżeli JBuilder nie znajdzie takiego pliku, zamiast przycisków zobaczymy parę tzw. „czerwonych komponentów” (ang. red components). Czerwone komponenty poja- wiają się w widoku projektowania wówczas, gdy JBuilder ma problemy z utworze- niem obiektów właściwych komponentów. Najczęściej powodem jest po prostu braku plików skompilowanych klas. Ćwiczenie 6.5. Aby — korzystając z możliwości projektowania RAD — zmienić rozmiar i położenie przycisków na powierzchni apletu: 1. Pozostajemy w widoku projektowania (zakładka Design). 2. W oknie struktury zaznaczamy obiekt apletu (VJKU). 3. Za pomocą inspektora zmieniamy właściwość NC[QWV apletu na PWNN. W ten sposób wyłączamy menedżera położenia komponentówm, co umożliwia ustalenie dowolnego rozmiaru i położenia komponentów.m 4. Korzystając z metod projektowania RAD, powiększamy przymciski na tyle, żeby widoczny był napis na jednym z nich. 5. Zaznaczamy przycisk OR na podglądzie apletu (nazwę zaznaczonego przycisku można sprawdzić w oknie struktury — jest tmam również zaznaczony). 6. Następnie za pomocą inspektora edytujemy jego właściwmość NCDGN odpowiadającą za treść etykiety. Niech napis na przycmisku brzmi JBuilder. Obiekty przycisków OR i OR zachowują się identycznie jak komponenty $WVVQP. Tak jak w przypadku innych komponentów wizualnych możemy za pomocą myszy dowolnie zmienić ich położenie i rozmiar, a także modyfikować inne ich właściwości korzystając z inspektora. Ćwiczenie 6.6. Aby upewnić się, czy komponenty umieszczone na aplecie nie są zwykłymi przyciskami typu $WVVQP, dodajmy na chwilę do konstruktorów klasy /KICLCE[2T[EKUM polecenia zmiany koloru tła: 236 JBuilder X. Efektywne programowanie w Javie 1. W edytorze przełączamy zakładkę plików na /KICLCE[2T[EKUM. 2. Importujemy klasę QNQT dodając polecenie na początku pliku apletu przed klasą KORQTVLCXCCYV QNQT 3. Uzupełniamy klasę o umieszczone w konstruktorach pomlecenia zmiany tła przycisków (wyróżnione fragmenty): RWDNKE/KICLCE[2T[EKUM VJTQYU*GCFNGUU ZEGRVKQP ] UGV$CEMITQWPF QNQTITGGP  _ RWDNKE/KICLCE[2T[EKUM 5VTKPINCDGN VJTQYU*GCFNGUU KZEGRVKQP ] UWRGT NCDGN  UGV$CEMITQWPF QNQT[GNNQY  _ No i proszę. Tła przycisków na podglądzie apletu /KICLCE[2T[EKUM GOQ lub po uru- chomieniu go w AppletTestbed (F9) zmieniły się. Możemy być więc pewni, że na po- wierzchni apletu rzeczywiście znajdują się dwa komponenty klasy /KICLCE[2T[EKUM (rysunek 6.3). Rysunek 6.3. Aplet z dwoma komponentami MigajacyPrzycisk, na razie jeszcze niemigającymi, uruchomiony w przeglądarce apletów JBuildera AppletTestbed Ćwiczenie 6.7. Aby sprawdzić, czy aplet działa w przeglądarce z wyłączmonym pluginem Java 2: 1. Uruchamiamy zewnętrzną przeglądarkę. Jeżeli to możliwe mwyłączamy plugin Java 2. 2. Wczytujemy stworzony przez JBuildera plik MigajacyPrzycisk.html, który znajduje się w podkatalogu classes projektu. 3. Po upewnieniu się, że aplet działa, wracamy do JBuildmera i usuwamy polecenia zmiany koloru tła z konstruktorów. Rozdział 6. ♦ Komponenty JavaBean od środka 237 Jak już wiemy, aby aplet uruchomił się w przeglądarce korzystającej z wirtualnej maszyny zgodnej z pierwszą specyfikacją Javy, konieczne jest, żeby podczas jego działania nie była wywoływana żadna metoda, która obecna jest dopiero w Java 2. W szczególności dotyczy to całego pakietu Swing2. Aplet, który stworzyliśmy, jest w pełni zgodny z wirtualną maszyną w wersji 1.1 bez względu na to, czy jest to VJM z JDK 1.1, czy wirtualna maszyna Javy dołączana do Internet Explorera przez Microsoft. Inaczej wygląda sprawa klasy komponentu /KIC åLCE[2T[EKUM. Proszę zwrócić uwagę, że zdefiniowane przez kreator konstruktory zawierają deklaracje możliwości zgłoszenia wyjątku *GCFNGUU ZEGRVKQP (zobacz li- sting 6.1), który, możemy się o tym przekonać w dokumentacji JDK, jest dostępny dopiero od wersji 1.4. Należy się zatem spodziewać, że ewentualne wystąpienie tego wyjątku spowoduje całkowite zatrzymanie działania apletu w przeglądarce niekorzy- stającej z wirtualnej maszyny Java 2. O to możemy się jednak nie obawiać, ponieważ zgłoszenie tego wyjątku wymaga sytuacji dość egzotycznej. Wyjątek ten jest zgłaszany, gdy kod konstruktora odwołuje się do klawiatury, monitora lub myszy w środowisku, w którym takie urządzenia nie istnieją. Podczas instalacji JDK dołączonego do JBuildera nie jest instalowany plugin Java 2 do przeglądarek. Jeżeli zainstalowaliśmy niezależnie JDK, możliwe jest, że prze- glądarki mają taki plugin jednak zainstalowany. Do celów testowania apletów i komponentów niekorzystających z Java 2, jak /KICLCE[2T[EKUM, dobrze jest go dezaktywować. W Windows można to zrobić w Panelu sterowania, ikona Java Plug- in. Aby upewnić się, która wersja wirtualnej maszyny Javy jest uruchamiana przez przeglądarkę, można wykorzystać stworzony specjalne do takich celów aplet +PHQ (zobacz rozdział 3.). Wykorzystanie interfejsu Runnable Do pilnowania, aby przycisk cyklicznie w równych odstępach czasu zmieniał kolory, najlepiej wykorzystać osobny wątek. Wątek będzie odpowiedzialny nie tylko za odmie- rzanie czasu, ale również za samą zamianę kolorów. W tym celu możemy ponownie zastosować rozwiązanie użyte w aplecie 2W\NG0C CU lub dla odmiany wykorzystać interfejs 4WPPCDNG, nadający korzystającej z niego klasie niektóre właściwości klasy wątku 6JTGCF. Szczerze mówiąc — niezbyt lubię interfejs 4WPPCDNG. Wolę sam tworzyć klasę wątku i definiować w niej metodę TWP tak, jak robiliśmy to w przypadku 2W\NG. Jednak ponie- waż wszystkiego warto się nauczyć, wbrew moim upodobaniom tym razem skorzystajmy z pomocy tego interfejsu. Ćwiczenie 6.8. Aby dodać do klasy /KICLCE[2T[EKUM interfejs 4WPPCDNG: Zobacz uwagi na ten temat w rozdziale 3. 2 238 JBuilder X. Efektywne programowanie w Javie 1. W edytorze przełączamy zakładkę plików (nad kodem) na m/KICLCE[2T[EKUM. 2. Z menu Wizards wybieramy Implement Interface…. Zobaczymy kreator o nazwie Implement Interface Wizard (rysunek 6.4). Rysunek 6.4. Kreator dodawania interfejsu do klasy 3. W rozwijanej liście Class znajduje się lista klas z bieżącego pliku, z której należy wybrać tę klasę, do której chcemy dodać interfemjs. W naszym pliku zdefiniowana jest wyłącznie klasa /KICLCE[2T[EKUM. 4. Kolejna rozwijana lista o nazwie Interface pozwala na wybranie interfejsu, który chcemy zaimplementować w klasie. 5. Jeżeli nie znajdziemy go pośród elementów listy, możemym go odszukać naciskając przycisk z trzema kropkami. Pojawi się okmno Search for Interface Class z drzewem interfejsu. Wybieramy gałąź LCXCNCPI, a na niej zaznaczamy interfejs 4WPPCDNG. Zamykamy okno dialogowe naciskając OK. 6. Dodajemy interfejs do klasy naciskając OK w oknie kreatora. Kreator wprowadził do definicji klasy dwie modyfikacje (listing 6.3). W sygnaturze klasy dodane zostało słowo kluczowe KORNGOGPVU z nazwą interfejsu, a do definicji klasy dodana została metoda TWP (na razie jedynie zgłaszająca wyjątek domagający się jej implementacji). Metoda TWP zadeklarowana jest w interfejsie 4WPPCDNG i musi być wobec tego zdefiniowana w korzystającej z tego interfejsu klasie. Wykorzystanie interfejsu 4WPPCDNG w klasie /KICLCE[2T[EKUM oznacza, że jej metoda TWP może być wykonywana w osobnym wątku. Ale nie stanie się to samo — należy ten wątek wła- snoręcznie uruchomić3. I to uruchomić w taki sposób, żeby wiedział, że jego zadaniem jest uruchomienie metody TWP z klasy migającego przycisku. 3 Częstą pomyłką jest przekonanie, że zdefiniowanie metondy TWP w klasie korzystającej z interfejsu 4WPPCDNG oznacza, że zostanie ona automatycznie uruchomionan w osobnym wątku. Niestety nie. Drugą równie częstą pomyłką jest pomysł, że jawne wywołannie metody TWP spowoduje jej wykonywanie w osobnym wątku. Tak również nie jest. Rozdział 6. ♦ Komponenty JavaBean od środka 239 Listing 6.3. Klasa MigajacyPrzycisk po dodaniu przez kreator inteirfejsu Runnable RWDNKEENCUU/KICLCE[2T[EKUMGZVGPFU$WVVQPKORNGOGPVU4WPPCDNG ] RWDNKE/KICLCE[2T[EKUM VJTQYU*GCFNGUU ZEGRVKQP ] _ RWDNKE/KICLCE[2T[EKUM 5VTKPINCDGN VJTQYU*GCFNGUU ZEGRVKQP ] UWRGT NCDGN  _ RWDNKEXQKFTWP ]  VQFQ+ORNGOGPVVJKULCXCNCPI4WPPCDNGOGVJQF  VJTQYPGYLCXCNCPI7PUWRRQTVGF1RGTCVKQP ZEGRVKQP /TGVJQFTWP PQV[GV KORNGOGPVGF  _ _ Ćwiczenie 6.9. Aby zdefiniować metodę WTWEJQO9CVGM, której zadaniem będzie uruchamianie wątku związanego z klasą /KICLCE[2T[EKUM: 1. Definiujemy jako pole klasy prywatną referencję do klamsy 6JTGCF o nazwie YCVGM (listing 6.4). 2. Definiujemy prywatną metodę WTWEJQO9CVGM bez argumentów i bez zwracanej wartości. Wewnątrz tej metody tworzymy obiekt klasym 6JTGCF korzystając z konstruktora, który jako argument pobiera klasę z imnterfejsem 4WPPCDNG. W naszym przypadku tym argumentem powinna być bieżąca klasa komponentu — używamy zatem referencji VJKU. Zwracany przez operator PGY adres zapisujemy do zmiennej YCVGM. 3. Dodajemy wywołanie metody WTWEJQO9CVGM do obu konstruktorów komponentu. 4. Usuwamy tymczasową zawartość metody TWP (dwie linie między nawiasami klamrowymi) i umieszczamy tam polecenie zmiany kolomru tła przycisku np. na niebieski. Pozwoli nam to upewnić się, czy wątmek rozpoczął niezależną pracę wykonując metodę TWP naszego przycisku. 5. Po kompilacji i uruchomieniu apletu (klawisz F9) powinniśmy zobaczyć na powierzchni apletu /KICLCE[2T[EKUM GOQ dwa niebieskie przyciski. Listing 6.4. Do automatycznego uruchomienia wątku po stworzeniu oibiektu klasy MigajacyPrzycisk korzystamy z pomocniczej prywatnej metody uruchomWateik RWDNKEENCUU/KICLCE[2T[EKUMGZVGPFU$WVVQPKORNGOGKPVU4WPPCDNG ] RTKXCVG6JTGCFYCVGMPWNN RWDNKE/KICLCE[2T[EKUM VJTQYU*GCFNGUU ZEGRVKQP ] 240 JBuilder X. Efektywne programowanie w Javie WTWEJQO9CVGM  _ RWDNKE/KICLCE[2T[EKUM 5VTKPINCDGN VJTQYU*GCFNGUKU ZEGRVKQP ] UWRGT NCDGN  WTWEJQO9CVGM  _ RTKXCVGXQKFWTWEJQO9CVGM ] YCVGMPGY6JTGCF VJKU  YCVGMUVCTV  _ RWDNKEXQKFTWP ] VJKUUGV$CEMITQWPF QNQTDNWG  _ _ Przypomnijmy podstawowe informacje na temat klasy 6JTGCF. Obiekt tej klasy repre- zentuje osobny niezależny wątek apletu lub aplikacji. Czynności wykonywane przez ten wątek określamy definiując metodę TWP klasy wątku. W typowym przypadku, który poznaliśmy w aplecie 2W\NG0C CU, metodę TWP zdefiniowaliśmy rozszerzając klasę 6JTGCF nadpisując nic nierobiącą metodę zdefiniowaną w klasie bazowej. Teraz metodę TWP mamy zdefiniowaną w klasie /KICLCE[2T[EKUM. Prosimy zatem obiekt YCVGM o wy- konanie właśnie tej metody wywołując konstruktor, w którym jako argument podajemy referencję do obiektu przycisku. Warunkiem jest, że obiekt ten musi korzystać z inter- fejsu 4WPPCDNG. Zdefiniowana przez nas metoda TWP na razie zmienia tylko kolor przycisku na niebieski. Zatem jeżeli po uruchomieniu apletu zobaczymy dwa niebieskie przyciski, możemy być pewni, że oba te obiekty uruchomiły osobne wątki mi wykonana została metoda TWP na rzecz każdego z nich. Po zakończeniu wykonywania metody TWP praca wątku auto- matycznie kończy się4. Ćwiczenie 6.10. Aby zdefiniować metodę TWP w taki sposób, żeby implementowała miganie przycisku z ustalonym okresem: 1. Deklarujemy w klasie /KICLCE[2T[EKUM prywatne pole klasy o nazwie QMTGU (przypominam, że należy ją umieścić wewnątrz klasy, ale mpoza jej metodami). Inicjujemy ją wartością 1000. Za jednostkę wybieramy milimsekundę, czyli tysięczną część sekundy. RTKXCVGNQPIQMTGU 4 Wyjątkiem jest sytuacja, w której wątek jest tzw. demnonem (zob. informację na ten temat w dokumentacji metody 6JTGCFUGV CGOQP). Rozdział 6. ♦ Komponenty JavaBean od środka 241 2. Definiujemy metodę TWP w następujący sposób: RWDNKEXQKFTWP ] YJKNG YCVGMPWNN ]  QNQTMQNQT0CRKUWVJKUIGV(QTGITQWPF   QNQTMQNQT6NCVJKUIGV$CEMITQWPF  VJKUUGV(QTGITQWPF MQNQT6NC  VJKUUGV$CEMITQWPF MQNQT0CRKUW  VT[]YCVGMUNGGR QMTGU _ ECVEJ +PVGTTWRVGF ZEGRVKQPGZE ]5[UVGOGTTRTKPVNPK GZEIGV/GUUCIG _ _ _ Działanie metody TWP opiera się na pętli YJKNG, która wykonywana jest dopóki, dopóty referencja YCVGM ma wartość różną od PWNN. Z tego wynika, że aby zakończyć działa- nie metody TWP i w ten sposób zakończyć działanie wątku, wystarczy zmienić wartość pola YCVGM na PWNN. Wewnątrz pętli tworzymy dwie zmienne pomocnicze przechowujące obecne kolory tła i etykiety przycisku. Następnie zamieniamy kolory przycisku miejscami i usypiamy wątek na czas określony przez QMTGU. Służąca do tego metoda 6JTGCFUNGGR, którą poznaliśmy już wcześniej, wymaga obsługi wyjątku +PVGTTWRVGF ZEGRVKQP — stąd odpowiednia konstrukcja VT[ECVEJ. Po uruchomieniu apletu lub w podglądzie na zakładce Design powinniśmy zobaczyć migające przyciski, które teraz rzeczywiście migają. Ćwiczenie 6.11. Aby po naciśnięciu przycisków umieszczonych na aplecie /KICLCE[2T[EKUM GOQ zmieniły się kolory, w jakich one migają: 1. Przechodzimy do apletu /KICLCE[2T[EKUM GOQ. Zapewne jest dostępny na górnej zakładce w oknie edytora. Jeżeli nie — trzemba w oknie projektu dwa razy kliknąć plik MigajacyPrzyciskDemo.java znajdujący się w pakiecie JGNKQPT. 2. Przełączamy okno edytora na widok projektowania (zakłmadka Design). 3. Dwukrotnie klikamy migający przycisk OR. Powstanie metoda zdarzeniowa związana z domyślnym zdarzeniem CEVKQP2GTHQTOGF tego obiektu. 4. Wewnątrz tej metody umieszczamy polecenia zmieniającme kolor tła na zielony, a etykiety na żółty: XQKFORACEVKQP2GTHQTOGF #EVKQP XGPVG ] ORUGV(QTGITQWPF QNQT[GNNQY  ORUGV$CEMITQWPF QNQTITGGP  _ 242 JBuilder X. Efektywne programowanie w Javie 5. Z drugim przyciskiem (OR) postępujemy podobnie. W jego przypadku zmieniamy kolory na pomarańczowy i różowy: XQKFORACEVKQP2GTHQTOGF #EVKQP XGPVG ] ORUGV(QTGITQWPF QNQTQTCPIG  ORUGV$CEMITQWPF QNQTRKPM  _ 6. Kompilujemy i uruchamiamy aplet (klawisz F9). 7. Aby zmienić kolory migających przycisków, należy tylko mkliknąć każdy z nich. W tym ćwiczeniu nie zmieniliśmy właściwości samych komponentów /KICLCE[2T[EKUM. Związaliśmy jedynie ze zdarzeniami dwóch konkretnych obiektów tego typu metody zmieniające kolory tych dwóch obiektów. To ćwiczenie pokazuje również, że dobrze nam znane metody ustalania koloru tła i etykiety przycisku nadal działają pozwalając teraz na wybór kolorów, w jakich miga przycisk. Ponadto przekonaliśmy się, że nie zmienił się także sposób obsługi zdarzeń w nowym komponencie /KICLCE[2T[EKUM. Ćwiczenie 6.12. Aby do migającego przycisku dodać możliwość opóźnienia rozpoczęcia migania po utworzeniu obiektu: 1. Wracamy do klasy /KICLCE[2T[EKUM (zakładka na górze edytora). 2. Deklarujemy kolejne globalne pole o nazwie QRQPKGPKG zainicjowane wartością 3000: RTKXCVGNQPIQRQPKGPKG 3. Uzupełniamy metodę TWP w następujący sposób (należy dopisać tylko wyróżnione dwie linie kodu): RWDNKEXQKFTWP ] VT[]YCVGMUNGGR QRQPKGPKG _ ECVEJ +PVGTTWRVGF ZEGRVKQPGZE ]5[UVGOGTTRTKPVNP GZETIGV/GUUCIG _ YJKNG YCVGMPWNN ]  QNQTMQNQT0CRKUWVJKUIGV(QTGITQWPF   QNQTMQNQT6NCVJKUIGV$CEMITQWPF  VJKUUGV(QTGITQWPF MQNQT6NC  VJKUUGV$CEMITQWPF MQNQT0CRKUW  VT[]YCVGMUNGGR QMTGU _ ECVEJ +PVGTTWRVGF ZEGRVKQPGZE ]5[UVGOGTTRTKPVNP GZEIGV/GUUCIG _ _ _ 1. Kompilujemy kod klasy naciskając Ctrl+F9. Rozdział 6. ♦ Komponenty JavaBean od środka 243 Idea jest prosta. Należy uśpić wątek na czas określony przez QRQPKGPKG, zanim roz- pocznie się pętla zmieniająca kolory. Aby zobaczyć efekt tej modyfikacji, można prze- łączyć edytor w widok projektowania lub uruchomić apmlet naciskając F9. Właściwości komponentów W rozdziale 2. kontrastowaliśmy zmienne i funkcje z polami i metodami klas. Tylko te drugie są dostępne w Javie. W językach związanych z programowaniem RAD istnieje zazwyczaj jeszcze jeden element klas — właściwość. Konstrukcja ta tworzy pewnego rodzaju pomost między metodami a polami klasy. Jej głównym zadaniem jest przy- gotowanie klasy komponentu do współpracy z narzędziammi typu inspektor. Jak przekonaliśmy się w rozdziale 2. na przykładzie klasy 7NCOGM, korzystanie z metod dostępu typu UGV jest właściwsze od bezpośredniego modyfikowania pól obiektu. Możliwa jest w ten sposób kontrola ustalanej wartości pola, a ponadto korzystanie z metody pozwala na synchronizację pozostałych właściwości obiektu, jeżeli te są w jakiś sposób zależne od modyfikowanego pola. Konstrukcja właściwości klasy wykorzystuje te korzyści wynikające z korzystania z metod dostępu podczas projek- towania RAD. Jak wspomniałem przed chwilą, do języków związanych z narzędziami typu RAD (np. Delphi i C++ Builder) dodawana jest konstrukcja, która udostępnia tzw. właściwość obiektu wiążąc parę metod IGV i UGV związanych z daną właściwością. W Object Pascalu należy właściwości zadeklarować osobno za pommocą słowa RTQRGTV[ (do C++ w C++ Builderze Borland dodał w tym celu niestandardowe słowo kluczowe AARTQRGTV[). Dla programisty używającego klasy korzystanie z właściwości5 niczym nie różni się od modyfikowania pola. Jednak różnica istnieje i to poważna; zmiana wartości właści- wości powoduje wywołanie metody UGV, a jej odczytanie — metody IGV. W Delphi i C++ Builderze właściwości obiektów mogą być dostępne w Object Inspector, jeżeli zadeklarowane są jako RWDNKUJGF — czyli opublikowane (nowy zakres dostępu). W Javie sytuacja jest nieco prostsza. Po pierwsze, nie istnieje specjalne słowo kluczowe pozwalające na konstruowanie właściwości. Przez to tworząc „ręcznie” kod źródłowy nadal mamy dostęp tylko do metod IGV i UGV. Po drugie, wszystkie środowiska programistyczne RAD Javy, w tym JBuilder, rozpoznają właściwości tylko po odpo- wiednio zdefiniowanej parze metod dostępu IGV i UGV i dodają tak określoną wła- ściwość do odpowiedników inspektora. W tej sytuacji z właściwości możemy korzystać jedynie podczas projektowania RAD. W kolejnych ćwiczeniach zajmiemy się tworzeniem metod dostępu do pól QMTGU i QRQPKGPKG, które będą rozpoznawane jako określające właściwości komponentu i zostaną dodane do właściwości widocznych w inspektorze. 5 Należy zwrócić uwagę, że w czystym C++ właściwością nazywa snię zazwyczaj to, co w Javie i Object Pascalu jest polem. Standard C++ nie zna konstrukcji wnłaściwości. Jest on dodany np. w C++ Builderze jako element niestandardowy (dlatego słowo kluczowe nRTQRGTV[ ma tu dwa znaki podkreślenia). 244 JBuilder X. Efektywne programowanie w Javie Można stworzyć te metody ręcznie, ale o wiele szybciej można je zdefiniować korzy- stając z minimalnego wsparcia, jakie w wersji JBuilder Foundation jest dostępne przy budowaniu komponentów JavaBean (szczątkowe fragmenty BeansExpress). Ćwiczenie 6.13. Aby przygotować metody pozwalające na czytanie i modyfikację właściwości QMTGU i QRQPKGPKG: 1. Zmieniamy zakładkę na górze okna edytora na MigajacyPrzycisk. Jeżeli nie jest dostępna, to korzystając z okna projektu, otwieramy plik MigajacyPrzycisk.java z pakietu JGNKQPT. 2. Dolną zakładkę edytora zmieniamy na Bean6, a w niej wybieramy podzakładkę Properties. 3. Zobaczymy tabelę z zadeklarowanymi polami klasy: YCVGM, QMTGU i QRQPKGPKG (rysunek 6.5) Kolumny tej tabeli to: nazwa właściwościm (Name), zadeklarowany typ (Type), możliwość pobrania wartości przez metodę IGV (Getter), możliwość zmodyfikowania wartości przechowywanej prmzez właściwość metodą UGV (Setter) oraz sposób związania (Binding). Rysunek 6.5. Jedyny element narzędzia BeansExpress dostępny w wersji Foundation 4. Przy właściwościach QMTGU i QRQPKGPKG zaznaczamy pozycje w kolumnach Getter i Setter. W kodzie klasy powstaną odpowiednie metody IGV1MTGU, UGV1MTGU, IGV1RQPKGPKG i UGV1RQPKGPKG. W ten sposób zwykłe pole zmieni się we właściwość. 6 Zakładka Bean ukrywa wspomniane wcześniej narzędzie BeansExpress. Niestety, w wersji Foundation jest ono nieaktywne. Jedyny element, który jest dosntępny, wykorzystujemy w tym ćwiczeniu. Rozdział 6. ♦ Komponenty JavaBean od środka 245 Jeżeli zajrzymy do kodu komponentu na zakładce Source, zauważymy nowe metody IGV1MTGU, UGV1MTGU, IGV1RQPKGPKG i UGV1RQPKGPKG. Ich budowa jest typowa dla metod dostępu do właściwości. Definiowaliśmy bardzo podobnme w klasie 7NCOGM w rozdziale 2. Możliwość automatycznego tworzenia metod IGV i UGV jest jedynie drobnym frag- mentem możliwości narzędzia o nazwie BeanExpress w pełni dostępnego na zakładce Bean tylko w wersjach komercyjnych JBuildera oraz przez miesiąc po zainstalowaniu jego darmowej wersji. Zakładka Properties, którą teraz wykorzystaliśmy, jest w wersji Foundation jedyną, jaka działa. Pozostałe zakładki po upływie miesiąca przełączane są w tryb tylko do odczytu. Ćwiczenie 6.14. Aby zobaczyć nowe właściwości: 1. Z menu Project wybieramy polecenie Rebuild Project helion.jpx . Naciśnięcie kombinacji klawiszy Ctrl+F9 odpowiadającej poleceniu Make Project helion.jpx z tego samego menu nie wystarczy, aby inspektor zobaczył nowe zdarzenia. Obecność metod IGVNazwa i UGVNazwa o odpowiednich sygnaturach jest wystarcza- jącym sygnałem dla inspektora, żeby dodał do listy właściwość nazwa. W naszym przypadku będą to właściwości QMTGU i QRQPKGPKG. Ćwiczenie 6.15. Aby w aplecie /KICLCE[2T[EKUM GOQ za pomocą inspektora zmienić okres migania przycisku OR na 500 milisekund: 1. W edytorze przechodzimy do klasy apletu /KICLCE[2T[EKUM GOQ. 2. Zmieniamy zakładkę na Design. 3. Zaznaczamy komponent OR. 4. W oknie inspektora zobaczymy wszystkie właściwości mkomponentu, a między nimi trzy nowe właściwości QMTGU i QRQPKGPKG. Zmieńmy właściwość QMTGU zaznaczonego komponentu na 500. Po wykonaniu ćwiczenia przycisk zacznie migać znacznime szybciej (dwa razy na sekundę). Ćwiczenie 6.16. Aby do komponentu dodać metody kontrolujące uruchamianie i zatrzymywanie wątku, a w konsekwencji włączać i wyłączać miganie przycisku: 1. W edytorze przechodzimy do klasy /KICLCE[2T[EKUM, zakładka Source. 2. Do klasy komponentu dodajemy metodę UGV/KICPKG9NCEQPG: 246 JBuilder X. Efektywne programowanie w Javie RWDNKEXQKFUGV/KICPKG9NCEQPG DQQNGCP/KICPKG9NCEQPGK ] KH /KICPKG9NCEQPG ] KH YCVGMPWNN WTWEJQO9CVGM  _ GNUGYCVGMPWNN _ 3. Dodajemy również metodę IGV/KICPKG9NCEQPG: RWDNKEDQQNGCPIGV/KICPKG9NCEQPG ] TGVWTP YCVGMPWNN  _ 4. Nie zmieniając zakładki klasy ani zakładki Source, kompilujemy projekt (Ctrl+F9). Po kompilacji w inspektorze pojawi się nowa właściwość o nazwie OKICPKG9NCEQPG, a przy niej rozwijana lista zawierająca dwie możliwe wartości True i False7. Warto wiedzieć, że w przypadku właściwości logicznych nazwa metody pobierającej wartość właściwości może rozpoczynać się od KU zamiast IGV. Ćwiczenie 6.17. Aby zatrzymać miganie przycisku w przypadku uruchomienia metody standardowej UVQR apletu /KICLCE[2T[EKUM GOQ oraz ponowić po wywołaniu metody UVCTV: 1. Przechodzimy do edycji klasy /KICLCE[2T[EKUM GOQ, zakładka Source. 2. Podczas tworzenia apletu /KICLCE[2T[EKUM GOQ zaznaczyliśmy opcję Generate standard methods, dzięki czemu kreator dodał do klasy apletu metody standardowe UVCTV, UVQR i FGUVTQ[8. 3. Do metody UVQR należy dodać wywołanie metod UGV/KICPKG9NCEQPG każdego z przycisków z argumentem HCNUG: RWDNKEXQKFUVQR ] ORUGV/KICPKG9NCEQPG HCNUG  ORUGV/KICPKG9NCEQPG HCNUG  _ 4. Analogicznie w metodzie UVCTV wywołujemy te same metody z argumentem VTWG: 7 8 Proszę zauważyć, że w klasie /KICLCE[2T[EKUM nie mamy zadeklarowanego pola typu logicznego o nazwie OKICPKG9NCEQPG. Nie jest ono konieczne. Dla Inspektora liczą się tylko metody UGV/KICPKG9NCEQPG i IGV/KICPKG9NCEQPG, na ich podstawie tworzy właściwość o nazwie OKICPKG9NCEQPG. Można je stworzyć również samodzielnie definiując samondzielnie bezargumentowe i niezwracające wartości metody publiczne, np. RWDNKEXQKFUVQR ]_. Więcej informacji na ten temat znajduje się w rozdziałach 1. oraz 3. Rozdział 6. ♦ Komponenty JavaBean od środka 247 RWDNKEXQKFUVCTV ] ORUGV/KICPKG9NCEQPG VTWG  ORUGV/KICPKG9NCEQPG VTWG  _ Definiowanie dodatkowych zdarzeń Czym są zdarzenia? Najłatwiej odpowiedzieć na to pytanie podając przykłady zdarzeń. Zdarzeniem może być kliknięcie przycisku przez użytkownika, może być nim również upłynięcie określo- nego czasu, rozpoczęcie lub zakończenie migania w naszym komponencie. Zdarzeniem może być każda sytuacja, której wystąpienie można sprawdzić za pomocą parametrów dostępnych w programie. W przypadku naszego komponentu /KICLCE[2T[EKUM możemy zdefiniować na przykład zdarzenie związane z rzeczywistym rozpoczęciem migania po odczekaniu okresu okre- ślonego przez QRQPKGPKG. Możemy również wywołać zdarzenie, gdy przycisk kończy miganie oraz przy każdym mignięciu. Zdefiniujemy wobecm tego trzy typy zdarzeń. Jak działa mechanizm zdarzeń w Javie? Jest to dość skomplikowane do wytłumaczenia, więc najpierw opiszę podobny przy- kład z życia. Załóżmy, że w pewnej uczelni przeprowadzany jest nabór na studia. Pisemne egzaminy już się odbyły i kandydaci na studentów czekają w domach na informację o tym, czy dostali się na studia i czy przyznane zostało im miejsce w aka- demiku. Pierwsza informacja zostanie wysłana w chwili ogłoszenia wyników, a druga po zakończeniu prac komisji rozdzielającej miejsca w akademikach. Zatem naszymi zdarzeniami są moment ogłoszenia wyników i moment zakończenia prac komisji ds. aka- demików. Zdarzenia te zostaną opisane w wysłanych do studenta oddzielnych listach, w których przekazana zostanie informacja o jego wynikach i o przyznaniu lub nie miejsca w akademiku. Sekretariat uczelni musi oczywiście posiadać listę kandydatów i tylko do nich wysyłana jest taka informacja. Żeby obraz jeszcze nieco skomplikować, przypomnę, że student nie dostaje listu do ręki. List jest wkładany do jego skrzynki pocztowej. Gdy student odbierze zawiadomienie z uczelni, w zależności od wyniku „uruchamiana jest jedna z jego metod”: radości lub smumtku. Podobnie realizowane są zdarzenia w Javie. Posłużmy się przykładem naszego kompo- nentu /KICLCE[2T[EKUM. Załóżmy, że /KICLCE[2T[EKUM ma mieć możliwość informowa- nia innych obiektów o rozpoczęciu i zakończeniu migania. W odpowiednich momentach migający przycisk powinien rozesłać do wszystkich zainteresowanych tym faktem obiektów informację o wystąpieniu zdarzenia. Informacja ta będzie oczywiście również obiektem — jak wszystko w Javie — musi więc być opisana przez klasę (powiedzmy, że będzie to zdefiniowana przez nas klasa /KICPKG XGPV; ta sama klasa będzie wyko- rzystywana w obu zdarzeniach). Ściślej rzecz biorąc, obiekt zostanie przekazany nie bezpośrednio do komponentu, ale do jego „skrzynki na listy” — obiektu towarzyszącego 248 JBuilder X. Efektywne programowanie w Javie nazywanego nasłuchiwaczem i tylko pod warunkiem, że nasłuchiwacz wcześniej zgłosił migającemu przyciskowi, że chce być o zdarzeniu informowany (nasłuchiwacz musi znajdować się na odpowiedniej liście w migającym przycisku). Dopiero z nasłu- chiwacza jest wywoływana metoda obiektu informowanego, która jest nazywana metodą zdarzeniową9. Jeżeli w migającym przycisku zdefiniowane są dwa zdarzenia (rozpoczęcie i zakoń- czenie migania), to nasłuchiwacz powinien posiadać dwie metody odpowiadające obu zdarzeniom. Student posiada tylko jedną skrzynkę na listy, ale wie, jaki typ listu otrzymał — na tej samej zasadzie w naszym przykładzie obiekt informowany o zdarzeniu ma tylko jeden nasłuchiwacz, a migający przycisk wywołuje odpowiednią metodę nasłu- chiwacza w zależności od tego, które zdarzenie wystąpimło. Musimy wobec tego posiadać dwie klasy towarzyszące komponentowi /KICLCE[2T[EKUM. Pierwsza to interfejs /KICPKG.KUVGPGT — obiekty tego typu to nasłuchiwacze, które zdefiniowane w otoczeniu migającego przycisku odbierają od migającego przycisku informacje o wystąpienia zdarzenia. Drugą jest klasa-nośnik informacji o zdarzeniu /KICPKG XGPV — obiekty tego typu są przekazywane z migającego przycisku do każdego zarejestrowanego w migającym przycisku nasłuchiwacza.m Podsumujmy. Aby np. aplet /KICLCE[2T[EKUM GOQ był informowany o zakończeniu migania przez /KICLCE[2T[EKUM, musi mieć towarzyszący mu obiekt-nasłuchiwacz implementujący interfejs /KICPKG.KUVGPGT. Nasłuchiwacz musi zgłosić migającemu przyciskowi, że chce być dopisany do listy obiektów informowanych o zakończeniu migania (metoda CFF#EVKQP.KUVGPGT migającego przycisku). Te czynności na szczęście wykonuje już za nas JBuilder. Wystarczy w inspektorze w zakładce Event dwa razy kliknąć odpowiednie zdarzenie. To jest dobrze nam znany element programowania RAD, który zwalnia nas z myślenia o całym mechanizmie zdarzeń tworząc połączenie między określonym zdarzeniem komponentu a metodą zdarzeniową apletu. Musimy tylko postarać się o to, żeby odpowiednie zdarzenia pojawiły się w inspektorze. I do tego właśnie doprowadzą kolejne ćwiczenia. Interfejs nasłuchiwacza i klasa opisująca zdarzenier A więc do dzieła! Dodajmy do ziarenka zdarzenie wywoływane, gdy przycisk zacznie migotać z uwzględnieniem opóźnienia, zdarzenie wywoływane, gdy miganie zostanie przerwane, oraz zdarzenie wywołane przy każdym mignięciu. Zdefiniujemy własną klasę zdarzenia /KICPKG XGPV przenoszącą informacje o zdarzeniu oraz własny interfejs nasłuchiwacza /KICPKG.KUVGPGT, którego zadaniem jest czekanie na wystąpienie zda- rzenia. Tak naprawdę własną klasę zdarzenia zdefiniujemy bardziej dla pokazania, jak to się robi, niż z rzeczywistej potrzeby. W poniższych przykładach bez problemu można by posłużyć się też standardową klasą zdarzeń LCXCWVKN XGPV1DLGEV. 9 Proponuję zajrzeć do rozdziału 4., gdzie samodzielnie ndefiniowaliśmy nasłuchiwacze w aplecie 2W\NG. To powinno nieco pomóc w zrozumieniu mechanizmu zdarnzeń. Rozdział 6. ♦ Komponenty JavaBean od środka 249 Ćwiczenie 6.18. Aby zdefiniować klasę /KICPKG XGPV, czyli nośnik informacji o zdarzeniu: 1. W menu File JBuildera wybieramy pozycję New Class… 2. W kreatorze klasy ustalamy: a) nazwę pakietu: JGNKQPT, b) nazwę klasy: /KICPKG XGPV, c) klasę bazową: LCXCWVKN XGPV1DLGEV. 3. Zaznaczamy tylko dwie opcje: Public oraz Override superclass constructor. 4. Klikamy OK. Powstanie skromna klasa, którą w przyszłości będzie można rozbudować tak, aby przenosiła np. szczegółowe informacje o zdarzeniu i stanie komponentu w trakcie jego wystąpienia. Na razie jedyną ważną przekazywaną przez tę klasę informacją jest właści- wość UQWTEG zdefiniowana w XGPV1DLGEV, która identyfikuje obiekt, w którym wystąpiło zdarzenie. Właściwość ta jest ustalana w momencie tworzenia obiektu zdarzenia; po- dajemy ją w argumencie jedynego konstruktora. Ćwiczenie 6.19. Aby zdefiniować interfejs nasłuchiwacza /KICPKG.KUVGPGT: 1. Wybieramy pozycję New z menu File. 2. W galerii obiektów na stronie General zaznaczamy ikonę Interface i naciskamy OK. 3. W kreatorze interfejsu wpisujemy: a) nazwę pakietu: JGNKQPT, b) nazwę interfejsu: /KICPKG.KUVGPGT, c) nazwę interfejsu bazowego: LCXCWVKN XGPV.KUVGPGT. 4. Naciskamy OK. 5. Za pomocą edytora dodajemy do interfejsu nasłuchiwaczma deklaracje publicznych metod, które będą wywoływane przez migającmy przycisk w momencie wystąpienia zdarzenia10. Metody nie zwracają żadnej wartości, a ich argumentem jest obiekt opisujący zdarzenie /KICPKG XGPV. Deklarujemy trzy metody: OKICPKG4QRQEGVG, OKICPKG CMQPEQPG, OKICPKG/KIPKGEKG (listing 6.5). 10 Więcej informacji o deklaracji metod w interfejsacnh znajduje się w rozdziale 2. 250 JBuilder X. Efektywne programowanie w Javie Listing 6.5. Interfejs MiganieListener RWDNKEKPVGTHCEG/KICPKG.KUVGPGTGZVGPFU XGPV.KUVGPGKT ] RWDNKEXQKFOKICPKG4QRQEGVG /KICPKG XGPVG  RWDNKEXQKFOKICPKG CMQPEQPG /KICPKG XGPVG  RWDNKEXQKFOKICPKG/KIPKGEKG /KICPKG XGPVG  _ Realizacja wywoływania zdarzeń w komponencie Komponent JavaBean musi przechowywać listę obiektów będących nasłuchiwaczami, które mają być powiadamiane o wystąpieniu poszczególnych zdarzeń. Najprościej zre- alizować taką listę za pomocą klasy 8GEVQT. Poza tym konieczne są metody dopisujące nasłuchiwacze do listy i usuwające z niej. Ćwiczenie 6.20. Aby do komponentu /KICLCE[2T[EKUM dodać listę zarejestrowanych nasłuchiwaczy: 1. Przechodzimy w edytorze do klasy komponentu (zakładkma MigajacyPrzycisk). Jeżeli jest to konieczne, otwieramy plik MigajacyPrzycisk.java w oknie projektu. 2. Importujemy klasę 8GEVQT poleceniem umieszczonym na początku pliku MigajacyPrzycisk.java za deklaracją nazwy pakietu, ale przed deklaracją klasy /KICLCE[2T[EKUM: KORQTVLCXCWVKN8GEVQT 3. Następnie wewnątrz klasy /KICLCE[2T[EKUM deklarujemy listę nasłuchiwaczy dodając do niej pole: RTKXCVG8GEVQTNKUVC/KICPKG.KUVGPGTU Prawdę mówiąc, to dodaliśmy do klasy komponentu jedynie referencję, a nie obiekt listy. Rzeczywisty obiekt zostanie stworzony w metodzie, którą zdefiniujemy w następnym ćwiczeniu. Ćwiczenie 6.21. Aby do klasy komponentu dodać metody pozwalające na zarejestrowanie i wyreje- strowanie nasłuchiwacza: 1. Pozostajemy w kodzie klasy /KICLCE[2T[EKUM. 2. Dodajemy do klasy definicję metody CFF/KICPKG.KUVGPGT dodającej nasłuchiwacz podany w argumencie do listy zdefiniowanej w poprzedmnim ćwiczeniu: RWDNKEU[PEJTQPKGFXQKFCFF/KICPKG.KUVGPGT /KICPKG.KUKVGPGTNKUVGPGT ] KH NKUVC/KICPKG.KUVGPGTPWNN NKUVC/KICPKG.KUVGPGTPKGY8GEVQT   Rozdział 6. ♦ Komponenty JavaBean od środka 251 KH NKUVC/KICPKG.KUVGPGTEQPVCKPU NKUVGPGT NKUVC/KICPKG.KUVGPGTCFF NGOGPV NKUVGPGT  _ 3. Dodajemy także definicję metody TGOQXG/KICPKG.KUVGPGT, która usuwa podany w argumencie nasłuchiwacz z listy: RWDNKEU[PEJTQPKGFXQKFTGOQXG/KICPKG.KUVGPGT /KICPKG.KUVGPGTNKUVGPGT ] KH NKUVC/KICPKG.KUVGPGTPWNNNKUVC/KICPKG.KUVGPGTKEQPVCKPU NKUVGPGT NKUVC/KICPKG.KUVGPGTTGOQXG NGOGPV NKUVGPGT K _ 4. Z menu Project wybierz Rebuild Project helion.jpx . Naciśnięcie kombinacji klawiszy Ctrl+F9 nie wystarczy, aby inspektor zobaczył nowe zdarzenmia. Definiując metody, posłużyliśmy się metodami klasy 8GEVQT: CFF NGOGPV i TGOQXG NGOGPV służącymi odpowiednio do dodania do listy i usunięcia z niej elementu podanego jako argument. Wykorzystaliśmy także metodę 8GEVQTEQPVCKPU sprawdzającą, czy obiekt podany w argumencie znajduje się na liście. Metoda CFF/KICPKG.KUVGPGT sprawdza najpierw, czy za referencją NKUVC/KICPKG.KUVGPGT kryje się obiekt, czy jest on może jeszcze niezdefiniowany. Jeżeli obiektu nie ma, tzn. referencja NKUVC/KICPKG.KUVGPGT ma wartość PWNN, tworzymy go nadając liście wstępny rozmiar równy 2. W następnej linii sprawdzamy metodą 8GEVQTEQPVCKPU, czy na liście jest już nasłuchiwacz, który chcemy dodać. Jeżeli nie, dodajemy go. Metoda pozwa- lająca usuwać elementy z listy nasłuchiwaczy TGOQXG/KICPKG.KUVGPGT sprawdza, czy lista istnieje oraz czy element usuwany znajduje się rzeczywiście na liście. Jeżeli oba warunki są spełnione, element jest usuwany metodą 8GEVQTTGOQXG NGOGPV. Modyfikator U[PEJTQPKGF został użyty, żeby zapobiec sytuacji, w której dwa wątki równocześnie próbują modyfikować listę nasłuchiwaczy. Użycie tego modyfikatora informuje wirtualną maszynę Javy, że metoda ma być wykonywana tylko przez jeden wątek w danym czasie. Drugi musi poczekać w „kolejce”. Dodanie tych metod do klasy ziarenka jest sygnałem dla inspektora, że powinien pokazać nowe zdarzenie na zakładce Events. Konieczne jest, co podkreśliłem w punkcie 4. ćwi- czenia, wywołanie polecenia Rebuild Project helion.jpx z menu Project, a nie tylko polecenia Make Project helion.jpx (lub prowadzącego do tego samego naciśnięcia kombinacji klawiszy Ctrl+F9). Nazwy zdarzeń odpowiadają nazwom metod zdefi- niowanych w interfejsie nasłuchiwacza. W inspektorze pojawią się więc zdarzenia: OKICPKG4QRQEGVG, OKICPKG CMQPEQPG i OKICPKG/KIPKGEKG. Ćwiczenie 6.22. Aby w aplecie testowym stworzyć metodę zdarzeniową odpowiadającą zdarzeniu OKICPKG/KIPKGEKG: 1. Przejdźmy w edytorze do apletu /KICLCE[2T[EKUM GOQ. 2. W widoku projektowania (zakładka Design edytora) zaznaczmy migający przycisk OR. 252 JBuilder X. Efektywne programowanie w Javie 3. Stwórzmy metodę zdarzeniową związaną ze zdarzeniem OKICPKG/KIPKGEKG tak, jak robiliśmy to wiele razy: a) zmieniamy w inspektorze zakładkę na Events, b) odnajdujemy zdarzenie OKICPKG/KIPKGEKG, c) klikamy dwukrotnie w jego polu edycyjnym. Do metody LD+PKV zostało dodane wywołanie zdefiniowanej przez nas przed chwilą metody rejestrującej nasłuchiwacz w komponencie OR: ORCFF/KICPKG.KUVGPGT PGY/KICLCE[2T[EKUM GOQAORAOKICPKKG#FCRVGT VJKU  Pliku apletu został również wzbogacony o deklarację klasy zewnętrznej określającej nasłuchiwacz /KICLCE[2T[EKUM GOQAORAOKICPKG#FCRVGT wykorzystującej zdefinio- wany przez nas interfejs /KICLCE[.KUVGPGT. W tej klasie zostały zdefiniowane trzy metody, które zadeklarowaliśmy jako abstrakcyjne w interfejsie. W tej chwili nietry- wialną wartość ma tylko metoda OKICPKG/KIPKGEKG, która wywołuje metodę zdarze- niową ORAOKICPKG/KIPKGEKG apletu. Ćwiczenie 6.23. Aby dodać do metody zdarzeniowej z poprzedniego ćwiczenia polecenia zmieniające kolor tła apletu: 1. Do stworzonej w poprzednim ćwiczeniu przez JBuildera metody zdarzeniowej dopisujemy polecenia zaznaczone na listingu 6.6. Listing 6.6. Metoda zdarzeniowa zmieniająca kolory tła apletu XQKFORAOKICPKG/KIPKGEKG /KICPKG XGPVG ] /KICLCE[2T[EKUMOR /KICLCE[2T[EKUM GIGV5QWTEG  VJKUUGV$CEMITQWPF ORIGV(QTGITQWPF  VJKUUGV(QTGITQWPF ORIGV$CEMITQWPF  _ W metodzie wykorzystałem informacje o kolorach obiektu OR wykorzystując referencję do tego obiektu, która została przekazana we właściwości UQWTEG w obiekcie zdarzenia G. Obiekt ten przekazany został do nasłuchiwacza, a z niego do metody zdarzeniowej. Metoda IGV5QWTEG (z ang. pobierz źródło) tego obiektu zwraca referencję do obiektu wywołującego zdarzenie OR. My wiemy, że źródło jest klasy /KICLCE[2T[EKUM, więc wykonujemy odpowiednie rzutowanie. Dzięki znajomości referencji do OR, a przez to informacji o jej kolorach, mogliśmy metodę zaprogramować w taki sposób, żeby kolory apletu były zamienione względem kolorów przycmisku. Do działania całego mechanizmu brakuje już tylko jednego elementu. Musimy w odpo- wiednich miejscach metody TWP komponentu wywołać zdarzenia, co znaczy, że musimy wywołać odpowiednie metody wszystkich nasłuchiwaczy (OKICPKG4QRQEGVG, OKICPKG å CMQPEQPG i OKICPKG/KIPKGEKG) znajdujących się na liście NKUVC/KICPKG.KUVGPGT. Rozdział 6. ♦ Komponenty JavaBean od środka 253 Ćwiczenie 6.24. Aby zdefiniować metody informujące nasłuchiwacze typu OKICPKG.KUVGPGT o wystą- pieniu zdarzeń w migającym przycisku: 1. Wracamy do klasy komponentu (zakładka MigajacyPrzycisk edytora). 2. Dodajemy do klasy metody z listingu 6.7. Listing 6.7. Metody informujące nasłuchiwacze o wystąpieniu zdarzeniia RTQVGEVGFXQKFY[YQNCL/KICPKG4QRQEGVG /KICPKG XGPVGK ] KH NKUVC/KICPKG.KUVGPGTPWNN TGVWTP HQT KPVKKNKUVC/KICPKG.KUVGPGTUKG K  /KICPKG.KUVGPGT NKUVC/KICPKG.KUVGPGTGNGOGPV#V K K OKICPKG4QRQEGVG G  _ RTQVGEVGFXQKFY[YQNCL/KICPKG CMQPEQPG /KICPKG XGPVKG ] KH NKUVC/KICPKG.KUVGPGTPWNN TGVWTP HQT KPVKKNKUVC/KICPKG.KUVGPGTUKG K  /KICPKG.KUVGPGT NKUVC/KICPKG.KUVGPGTGNGOGPV#V K K OKICPKG CMQPEQPG G  _ RTQVGEVGFXQKFY[YQNCL/KICPKG/KIPKGEKG /KICPKG XGPVKG ] KH NKUVC/KICPKG.KUVGPGTPWNN TGVWTP HQT KPVKKNKUVC/KICPKG.KUVGPGTUKG K  /KICPKG.KUVGPGT NKUVC/KICPKG.KUVGPGTGNGOGPV#V K OKICPKG/KIPKGEKG G  _ Pierwsza metoda będzie wykorzystana do powiadomienia nasłuchiwaczy o rozpoczęciu migania, druga o zakończeniu, a trzecia o każdym mignięcmiu. W każdej metodzie sprawdzamy najpierw, czy lista NKUVC/KICPKG.KUVGPGT jest w ogóle zdefiniowana, czyli czy jest kogo powiadamiać. Jeżeli lista istnieje, to na rzecz każdego jej elementu wywołujemy odpowiednio metody OKICPKG4QRQEGVG, OKICPKG CMQPEQPG lub OKICPKG/KIPKGEKG podając jako argument obiekt typu /KICPKG XGPV. Aby uruchomić cały zdefiniowany w tym paragrafie mechanizm zdarzeń, należy teraz umieścić wywołanie metod Y[YQNCL/KICPKG4QRQEGVG, Y[YQN
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

JBuilder X. Efektywne programowanie w Javie
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: