Darmowy fragment publikacji:
IDZ DO
IDZ DO
PRZYK£ADOWY ROZDZIA£
PRZYK£ADOWY ROZDZIA£
SPIS TREĎCI
SPIS TREĎCI
Java. Receptury
KATALOG KSI¥¯EK
KATALOG KSI¥¯EK
KATALOG ONLINE
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
ZAMÓW DRUKOWANY KATALOG
Autor: Ian F. Darwin
T³umaczenie: Piotr Rajca
ISBN: 83-7197-902-9
Tytu³ orygina³u: Java Cookbook
Format: B5, stron: 886
Przyk³ady na ftp: 1157 kB
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
Ksi¹¿ka „Java. Receptury” zawiera kolekcjê rozwi¹zañ setek problemów, z którymi
programiġci u¿ywaj¹cy jêzyka Java spotykaj¹ siê bardzo czêsto. Receptury znajduj¹
zastosowanie w szerokim spektrum zagadnieñ: od ca³kiem prostych, takich jak
okreġlanie zmiennej ġrodowiskowej CLASSPATH, a¿ do ca³kiem z³o¿onych programów
pokazuj¹cych jak obs³ugiwaæ dokumenty XML lub wzbogaciæ sw¹ aplikacjê
o mechanizmy obs³ugi poczty elektronicznej.
Niezale¿nie od tego, jak planujesz wykorzystaæ tê ksi¹¿kê — czy jako ĥród³o pomys³ów
i inspiracji, czy te¿ jako sposób poszerzenia swej wiedzy o jêzyku Java — zawsze bêdzie
ona stanowiæ wa¿n¹ czêġæ Twojej biblioteki. Ma³o która ksi¹¿ka prezentuje tak wiele
mo¿liwoġci Javy oraz nauczy Ciê praktycznego wykorzystania omawianych zagadnieñ.
W ksi¹¿ce zosta³y omówione nastêpuj¹ce zagadnienia:
• Kompilacja, uruchamianie oraz testowanie programów napisanych w Javie
• Interakcja ze ġrodowiskiem
• £añcuchy znaków oraz dopasowywanie wzorców
• Tablice oraz inne kolekcje danych
• Programowa obs³uga portów szeregowych i równoleg³ych
• Pliki, katalogi i system plików
• Tworzenie programów sieciowych pe³ni¹cych funkcje klientów oraz serwerów
• Aplikacje internetowe, w tym tak¿e aplety
• Serwlety oraz dokumenty JSP
• Poczta elektroniczna
• Obs³uga baz danych
• Wykorzystanie XML
• Programowanie rozproszone
• Introspekcja
• Tworzenie programów wielojêzycznych
• Wykorzystanie grafiki oraz dĥwiêku
• Tworzenie graficznego interfejsu u¿ytkownika
Spis treści
Wstęp................................................................................................................................ 15
Rozdział 1. Rozpoczynanie pracy: kompilacja, uruchamianie i testowanie ... 31
1.0. Wprowadzenie...................................................a...................................................a............. 31
1.1. Kompilacja i uruchamianie programów napisanych w Javie — JDK................................ 32
1.2. Edycja i kompilacja programów przy użyciu edytorów wyposażonych
w kolorowanie syntaktyczne...................................................a.......................................... 37
1.3. Kompilacja, uruchamianie i testowanie programów przy użyciu IDE ............................. 39
1.4. Wykorzystanie klas przedstawionych w niniejszej książce............................................... 44
1.5. Automatyzacja kompilacji przy wykorzystaniu skryptu jr ............................................... 45
1.6. Automatyzacja procesu kompilacji przy użyciu programu make..................................... 46
1.7. Automatyzacja kompilacji przy użyciu programu Ant...................................................a.. 48
1.8. Uruchamianie apletów ...................................................a...................................................a51
1.9. Komunikaty o odrzuconych metodach ...................................................a.......................... 53
1.10. Testowanie warunkowe bez użycia dyrektywy #ifdef ...................................................a. 55
1.11. Komunikaty testowe...................................................a...................................................a.. 57
1.12. Wykorzystanie programu uruchomieniowego...................................................a............. 58
1.13. Testowanie jednostkowe — jak uniknąć konieczności stosowania
programów uruchomieniowych?...................................................a.................................. 60
1.14. Dekompilacja plików klasowych Javy ...................................................a.......................... 63
1.15. Zapobieganie możliwości dekompilacji plików klasowych Javy..................................... 65
1.16. Uzyskiwanie czytelnych komunikatów o wyjątkach...................................................a.... 66
1.17. Poszukiwanie przykładowych kodów źródłowych...................................................a...... 68
1.18. Program Debug...................................................a...................................................a.......... 70
Rozdział 2.
Interakcja ze środowiskiem...................................................o......... 71
2.0. Wprowadzenie...................................................a...................................................a............. 71
2.1. Pobieranie wartości zmiennych środowiskowych...................................................a.......... 71
4
Spis treści
2.2. Właściwości systemowe ...................................................a................................................. 73
2.3. Tworzenie kodu zależnego od używanej wersji JDK...................................................a..... 75
2.4. Tworzenie kodu zależnego od używanego systemu operacyjnego .................................. 77
2.5. Efektywne wykorzystanie zmiennej CLASSPATH ...................................................a........ 79
2.6. Stosowanie rozszerzających interfejsów programistycznych lub API
zapisanych w plikach JAR...................................................a.............................................. 82
2.7. Analiza argumentów podanych w wierszu wywołania programu................................... 83
Rozdział 3. Łańcuchy znaków i przetwarzanie tekstów.................................. 89
3.0. Wprowadzenie...................................................a...................................................a............. 89
3.1. Odczytywanie fragmentów łańcucha ...................................................a............................. 92
3.2. Dzielenie łańcuchów znaków za pomocą obiektu klasy StringTokenizer......................... 93
3.3. Łączenie łańcuchów znaków przy użyciu operatora + i klasy StringBuffer ..................... 96
3.4. Przetwarzanie łańcucha znaków po jednej literze...................................................a.......... 97
3.5. Wyrównywanie łańcuchów znaków...................................................a............................... 98
3.6. Konwersja pomiędzy znakami Unicode a łańcuchami znaków ...................................... 101
3.7. Odwracanie kolejności słów lub znaków w łańcuchu...................................................a.. 102
3.8. Rozwijanie i kompresja znaków tabulacji..................................................a...................... 104
3.9. Kontrola wielkości liter.........................a...................................................a........................ 108
3.10. Wcinanie zawartości dokumentów tekstowych ...................................................a......... 109
3.11. Wprowadzanie znaków niedrukowalnych...................................................a................. 111
3.12. Usuwanie odstępów z końca łańcucha ...................................................a....................... 112
3.13. Przetwarzanie danych rozdzielonych przecinkami ...................................................a.... 113
3.14. Program — proste narzędzie do formatowania tekstów............................................... 118
3.15. Program — fonetyczne porównywanie nazwisk...................................................a........ 120
Rozdział 4. Dopasowywanie wzorców i wyrażenia regularne ...................... 125
4.0. Wprowadzenie...................................................a...................................................a........... 125
4.1. Składnia wyrażeń regularnych ...................................................a..................................... 128
4.2. Jak wyrażenia regularne działają w praktyce? ...................................................a............. 130
4.3. Wykorzystanie wyrażeń regularnych w języku Java ...................................................a... 132
4.4. Interaktywne testowanie wyrażeń regularnych ...................................................a........... 134
4.5. Określanie tekstu pasującego do wzorca...................................................a...................... 135
4.6. Zastępowanie określonego tekstu ...................................................a................................ 136
4.7. Wyświetlanie wszystkich wystąpień wzorca ...................................................a............... 137
4.8. Wyświetlanie wierszy zawierających fragment pasujący do wzorca.............................. 139
4.9. Kontrola wielkości znaków w metodach match() i subst() ............................................. 141
4.10. Prekompilacja wyrażeń regularnych...................................................a........................... 141
Spis treści
5
4.11. Odnajdywanie znaków nowego wiersza...................................................a.................... 143
4.12. Program — analizowanie danych...................................................a............................... 144
4.13. Program — pełna wersja programu grep...................................................a................... 146
Rozdział 5. Liczby...................................................o.......................................... 151
5.0. Wprowadzenie...................................................a...................................................a........... 151
5.1. Sprawdzanie, czy łańcuch znaków stanowi poprawną liczbę......................................... 154
5.2. Zapisywanie dużych wartości w zmiennych „mniejszych” typów................................. 155
5.3. Pobieranie ułamka z liczby całkowitej bez konwertowania go
do postaci zmiennoprzecinkowej...................................................a................................. 156
5.4. Wymuszanie zachowania dokładności liczb zmiennoprzecinkowych............................ 158
5.5. Porównywanie liczb zmiennoprzecinkowych ...................................................a.............. 160
5.6. Zaokrąglanie wartości zmiennoprzecinkowych ...................................................a........... 161
5.7. Formatowanie liczb ...................................................a...................................................a... 162
5.8. Konwersje pomiędzy różnymi systemami liczbowymi
— dwójkowym, ósemkowym, dziesiętnym i szesnastkowym ....................................... 165
5.9. Operacje na grupie liczb całkowitych...................................................a........................... 166
5.10. Posługiwanie się cyframi rzymskimi...................................................a.......................... 167
5.11. Formatowanie z zachowaniem odpowiedniej postaci liczby mnogiej........................... 172
5.12. Generowanie liczb losowych ...................................................a...................................... 173
5.13. Generowanie lepszych liczb losowych ...................................................a....................... 174
5.14. Obliczanie funkcji trygonometrycznych ...................................................a..................... 176
5.15. Obliczanie logarytmów...................................................a............................................... 176
5.16. Mnożenie macierzy...................................................a...................................................a..177
5.17. Operacje na liczbach zespolonych...................................................a............................... 179
5.18. Obsługa liczb o bardzo dużych wartościach ...................................................a.............. 181
5.19. Program TempConverter...................................................a............................................ 183
5.20. Program — generowanie liczbowych palindromów ...................................................a.. 186
Rozdział 6. Daty i godziny...................................................o............................ 191
6.0. Wprowadzenie...................................................a...................................................a........... 191
6.1. Określanie bieżącej daty ...................................................a...............................................193
6.2. Wyświetlanie daty i czasu w zadanym formacie ...................................................a......... 194
6.3. Przedstawianie dat w innych systemach...................................................a...................... 196
6.4. Konwersja liczb określających datę i czas na obiekt Calendar lub ilość sekund............. 197
6.5. Analiza łańcuchów znaków i ich zamiana na daty...................................................a....... 198
6.6. Konwersja dat wyrażonych w formie sekund na obiekt Date......................................... 200
6.7. Dodawanie i odejmowanie dat przy wykorzystaniu klas Date oraz Calendar............... 201
6
Spis treści
6.8. Obliczanie różnic pomiędzy dwiema datami...................................................a............... 202
6.9. Porównywanie dat................................a...................................................a........................ 203
6.10. Określanie dnia tygodnia, miesiąca lub roku oraz numeru tygodnia ........................... 205
6.11. Wyświetlanie kalendarza...................................................a............................................ 207
6.12. Czasomierze o dużej dokładności..................................................a................................ 209
6.13. Wstrzymywanie wykonywania programu ...................................................a................. 211
6.14. Program — usługa przypominająca ...................................................a........................... 212
Rozdział 7. Strukturalizacja danych w języku Java ...................................... 215
7.0. Wprowadzenie...................................................a...................................................a........... 215
7.1. Strukturalizacja danych przy użyciu tablic...................................................a................... 216
7.2. Modyfikacja wielkości tablic...................................................a......................................... 218
7.3. Klasa podobna do tablicy, lecz bardziej dynamiczna...................................................a... 219
7.4. Iteratory — dostęp do danych w sposób niezależny od ich typów ................................ 221
7.5. Strukturalizacja danych przy wykorzystaniu list połączonych ....................................... 223
7.6. Odwzorowywanie przy wykorzystaniu klas Hashtable oraz HashMap ........................ 225
7.7. Zapisywanie łańcuchów znaków w obiektach Properties i Preferences ......................... 226
7.8. Sortowanie kolekcji...................................................a...................................................a.... 230
7.9. Sortowanie w języku Java 1.1...................................................a....................................... 234
7.10. Unikanie konieczności sortowania danych...................................................a................. 235
7.11. Zbiory ...................................................a...................................................a...................... 237
7.12. Odnajdywanie obiektu w kolekcji ...................................................a.............................. 238
7.13. Zamiana kolekcji na tablicę...................................................a......................................... 240
7.14. Tworzenie własnego iteratora...................................................a..................................... 241
7.15. Stos............................................a...................................................a.................................. 243
7.16. Struktury wielowymiarowe...................................................a........................................ 244
7.17. Kolekcje.......................................a...................................................a................................ 246
7.18. Program — porównanie szybkości działania ...................................................a............. 246
Rozdział 8. Techniki obiektowe ...................................................o.................... 251
8.0. Wprowadzenie...................................................a...................................................a........... 251
8.1. Wyświetlanie obiektów — formatowanie obiektów przy użyciu metody toString() ...... 253
8.2. Przesłanianie metody equals ...................................................a........................................ 255
8.3. Przesłanianie metody hashCode...................................................a................................... 257
8.4. Metoda clone ...................................................a...................................................a............. 259
8.5. Metoda finalize ...................................................a...................................................a.......... 261
8.6. Wykorzystanie klas wewnętrznych...................................................a.............................. 263
8.7. Tworzenie metod zwrotnych przy wykorzystaniu interfejsów....................................... 264
Spis treści
7
8.8. Polimorfizm i metody abstrakcyjne...................................................a.............................. 268
8.9. Przekazywanie wartości ...................................................a............................................... 270
8.10. Zgłaszanie własnych wyjątków ...................................................a.................................. 273
8.11. Program Plotter...................................................a...................................................a........ 274
Rozdział 9. Wejście i wyjście...................................................o........................ 277
9.0. Wprowadzenie...................................................a...................................................a........... 277
9.1. Odczytywanie informacji ze standardowego strumienia wejściowego........................... 282
9.2. Zapis danych w standardowym strumieniu wyjściowym .............................................. 285
9.3. Otwieranie pliku o podanej nazwie...................................................a.............................. 287
9.4. Kopiowanie plików ...................................................a...................................................a...287
9.5. Odczytywanie zawartości pliku i zapisywanie jej w obiekcie String .............................. 291
9.6. Zmiana skojarzeń strumieni standardowych ...................................................a............... 292
9.7. Powielanie strumienia podczas realizacji operacji zapisu............................................... 293
9.8. Odczyt i zapis danych zakodowanych w innym zbiorze znaków .................................. 296
9.9. Te kłopotliwe znaki końca wiersza...................................................a............................... 297
9.10. Kod operujący na plikach w sposób zależny od systemu operacyjnego....................... 298
9.11. Odczytywanie „podzielonych” wierszy tekstu ...................................................a.......... 299
9.12. Analiza zawartości pliku ...................................................a............................................ 304
9.13. Dane binarne...................................................a...................................................a............ 309
9.14. Przeszukiwanie...................................................a...................................................a........ 310
9.15. Zapisywanie danych w strumieniu przy wykorzystaniu języka C ............................... 311
9.16. Zapisywanie i odczytywanie serializowanych obiektów .............................................. 313
9.17. Unikanie wyjątków ClassCastException spowodowanych nieprawidłowymi
wartościami SerialVersionUID...................................................a.................................... 315
9.18. Odczytywanie i zapisywanie danych w archiwach JAR oraz Zip................................. 317
9.19. Odczytywanie i zapisywanie plików skompresowanych.............................................. 320
9.20. Program — zamiana tekstu do postaci PostScript...................................................a...... 322
9.21. Program TarList (konwerter plików)...................................................a.......................... 324
Rozdział 10. Operacje na katalogach i systemie plików ................................. 337
10.0. Wprowadzenie...................................................a...................................................a......... 337
10.1. Pobieranie informacji o pliku...................................................a...................................... 338
10.2. Tworzenie pliku...................................................a...................................................a....... 341
10.3. Zmiana nazwy pliku...................................................a...................................................a 342
10.4. Usuwanie plików...................................................a...................................................a..... 342
10.5. Tworzenie plików tymczasowych ...................................................a.............................. 344
10.6. Zmiana atrybutów pliku...................................................a............................................. 346
8
Spis treści
10.7. Tworzenie listy zawartości katalogu ...................................................a.......................... 347
10.8. Pobieranie katalogów głównych...................................................a................................. 349
10.9. Tworzenie nowych katalogów...................................................a.................................... 351
10.10. Program Find ...................................................a...................................................a......... 352
Rozdział 11. Programowa obsługa portu szeregowego i równoległego........... 355
11.0. Wprowadzenie...................................................a...................................................a......... 355
11.1. Wybieranie portu...................................................a...................................................a..... 358
11.2. Otwieranie portu szeregowego...................................................a................................... 361
11.3. Otwieranie portu równoległego ...................................................a................................. 365
11.4. Rozwiązywanie konfliktów portów...................................................a............................ 368
11.5. Odczyt i zapis — metoda krokowa ...................................................a............................ 372
11.6. Odczyt i zapis — przetwarzanie sterowane zdarzeniami ............................................. 374
11.7. Odczyt i zapis — wątki..................................................a................................................ 378
11.8. Program — obsługa plotera Penman...................................................a.......................... 380
Rozdział 12. Grafika i dźwięk ...................................................o........................ 385
12.0. Wprowadzenie...................................................a...................................................a......... 385
12.1. Rysowanie przy użyciu obiektu Graphics...................................................a.................. 386
12.2. Testowanie komponentów graficznych ...................................................a...................... 387
12.3. Wyświetlane tekstu...................................................a...................................................a.. 389
12.4. Wyświetlanie wyśrodkowanego tekstu w komponencie .............................................. 389
12.5. Rysowanie cienia ...................................................a...................................................a..... 391
12.6. Wyświetlanie obrazu ...................................................a.................................................. 393
12.7. Odtwarzanie pliku dźwiękowego ...................................................a.............................. 398
12.8. Prezentacja ruchomego obrazu...................................................a................................... 399
12.9. Wyświetlanie tekstu przy użyciu biblioteki grafiki dwuwymiarowej........................... 402
12.10. Drukowanie — JDK 1.1...................................................a............................................. 405
12.11. Drukowanie — Java 2 ...................................................a............................................... 408
12.12. Program Ploter AWT ...................................................a................................................ 410
12.13. Program Grapher...................................................a...................................................a...412
Rozdział 13. Graficzny interfejs użytkownika.................................................. 417
13.0. Wprowadzenie...................................................a...................................................a......... 417
13.1. Wyświetlanie komponentów graficznego interfejsu użytkownika................................ 419
13.2. Projektowanie układu okna ...................................................a........................................ 420
13.3. Zakładki — nowe spojrzenie na świat...................................................a........................ 423
13.4. Obsługa czynności — tworzenie działających przycisków............................................ 424
13.5. Obsługa czynności przy wykorzystaniu anonimowych klas wewnętrznych ................ 427
Spis treści
9
13.6. Kończenie programu przy użyciu przycisku „Zamknij”............................................... 429
13.7. Okna dialogowe — tego nie można zrobić później ...................................................a.... 434
13.8. Wyświetlanie wyników wykonania programu w oknie................................................ 436
13.9. Wybieranie plików przy użyciu klasy JFileChooser...................................................a... 439
13.10. Wybieranie koloru ...................................................a...................................................a.443
13.11. Wyświetlanie okna głównego pośrodku ekranu ...................................................a...... 445
13.12. Zmiana sposobów prezentacji programów
pisanych z wykorzystaniem pakietu Swing...................................................a.............. 447
13.13. Program — własne narzędzie do wybierania czcionek ............................................... 451
13.14. Program — własny menedżer układu ...................................................a...................... 456
Rozdział 14. Tworzenie programów wielojęzycznych oraz lokalizacja.......... 463
14.0. Wprowadzenie...................................................a...................................................a......... 463
14.1. Tworzenie przycisku w różnych wersjach językowych................................................. 464
14.2. Tworzenie listy dostępnych ustawień lokalnych...................................................a........ 466
14.3. Tworzenie menu przy wykorzystaniu zasobów wielojęzycznych ................................ 467
14.4. Tworzenie metod pomocniczych, przydatnych przy tworzeniu
programów wielojęzycznych...................................................a...................................... 468
14.5. Tworzenie okien dialogowych przy wykorzystaniu zasobów wielojęzycznych........... 470
14.6. Tworzenie wiązki zasobów ...................................................a........................................ 471
14.7. Przygotowywanie programów wielojęzycznych...................................................a........ 473
14.8. Wykorzystanie konkretnych ustawień lokalnych...................................................a....... 474
14.9. Określanie domyślnych ustawień lokalnych ...................................................a.............. 475
14.10. Formatowanie komunikatów...................................................a.................................... 476
14.11. Program MenuIntl...................................................a...................................................a..478
14.12. Program BusCard...................................................a...................................................a...480
Rozdział 15. Klienty sieciowe ...................................................o......................... 485
15.0. Wprowadzenie...................................................a...................................................a......... 485
15.1. Nawiązywanie połączenia z serwerem...................................................a....................... 487
15.2. Odnajdywanie i zwracanie informacji o adresach sieciowych....................................... 489
15.3. Obsługa błędów sieciowych ...................................................a....................................... 490
15.4. Odczyt i zapis danych tekstowych ...................................................a............................. 491
15.5. Odczyt i zapis danych binarnych...................................................a................................ 494
15.6. Odczyt i zapis danych serializowanych...................................................a...................... 496
15.7. Datagramy UDP ...................................................a...................................................a......498
15.8. Program — klient TFTP wykorzystujący protokół UDP ............................................... 501
15.9. Program — klient usługi Telnet...................................................a.................................. 505
15.10. Program — klient pogawędek internetowych ...................................................a.......... 507
10
Spis treści
Rozdział 16. Programy Javy działające na serwerze — gniazda .................... 513
16.0. Wprowadzenie...................................................a...................................................a......... 513
16.1. Tworzenie serwera...................................................a...................................................a... 514
16.2. Zwracanie odpowiedzi (łańcucha znaków bądź danych binarnych)............................. 517
16.3. Zwracanie informacji o obiektach...................................................a............................... 521
16.4. Obsługa wielu klientów...................................................a.............................................. 522
16.5. Rejestracja operacji sieciowych ...................................................a................................... 527
16.6. Program — serwer pogawędek w Javie ...................................................a..................... 531
Rozdział 17. Klienty sieciowe II — aplety i klienty WWW ............................ 537
17.0. Wprowadzenie...................................................a...................................................a......... 537
17.1. Osadzanie apletów w stronach WWW ...................................................a....................... 538
17.2. Techniki tworzenia apletów...................................................a........................................ 539
17.3. Nawiązywanie połączenia z komputerem, z którego pobrano aplet ............................ 542
17.4. Wyświetlanie dokumentu z poziomu apletu...................................................a.............. 545
17.5. Uruchamianie skryptu CGI z poziomu apletu ...................................................a........... 547
17.6. Odczyt zawartości zasobu wskazywanego przez adres URL........................................ 549
17.7. Pobieranie znaczników HTML z dokumentu o podanym adresie URL ....................... 550
17.8. Pobieranie adresów URL zapisanych w pliku...................................................a............ 552
17.9. Zamiana nazwy pliku na adres URL ...................................................a.......................... 554
17.10. Program MkIndex...................................................a...................................................a.. 555
17.11. Program LinkChecker...................................................a............................................... 559
Rozdział 18. Programy działające na serwerach — sewlety i JSP.................. 567
18.0. Wprowadzenie...................................................a...................................................a......... 567
18.1. Pierwszy serwlet — generowanie strony WWW...................................................a........ 569
18.2. Serwlety — przetwarzanie danych przekazywanych z formularzy .............................. 572
18.3. Cookies ...................................................a...................................................a.................... 575
18.4. Śledzenie sesji ...................................................a...................................................a.......... 579
18.5. Generowanie plików PDF przez serwlety ...................................................a.................. 585
18.6. Połączenie HTML-a i Javy — JSP...................................................a................................ 591
18.7. Dołączanie plików i przekierowania w JSP ...................................................a................ 596
18.8. Strony JSP wykorzystujące serwlety...................................................a........................... 597
18.9. Upraszczanie kodu stron JSP dzięki wykorzystaniu komponentów JavaBeans............ 598
18.10. Składnia JSP....................................a...................................................a........................... 603
18.11. Program CookieCutter...................................................a.............................................. 603
18.12. Program — portal informacyjny JabaDot...................................................a.................. 604
Spis treści
11
Rozdział 19. Java i poczta elektroniczna...................................................o....... 617
19.0. Wprowadzenie...................................................a...................................................a......... 617
19.1. Wysyłanie poczty elektronicznej — wersja działająca w przeglądarkach ..................... 618
19.2. Wysyłanie poczty elektronicznej — właściwe rozwiązanie........................................... 622
19.3. Dodawanie możliwości wysyłania poczty do programu działającego na serwerze ..... 625
19.4. Wysyłanie wiadomości MIME...................................................a.................................... 631
19.5. Tworzenie ustawień poczty elektronicznej...................................................a................. 634
19.6. Wysyłanie poczty elektronicznej bez użycia JavaMail .................................................. 636
19.7. Odczytywanie poczty elektronicznej ...................................................a.......................... 640
19.8. Program MailReaderBean...................................................a........................................... 645
19.9. Program MailClient ...................................................a...................................................a.648
Rozdział 20. Dostęp do baz danych...................................................o................ 659
20.0. Wprowadzanie.................................a...................................................a........................... 659
20.1. Baza danych składająca się z plików tekstowych...................................................a....... 661
20.2. Bazy danych DBM ...................................................a...................................................a... 666
20.3. Konfiguracja i nawiązywanie połączeń JDBC...................................................a............. 669
20.4. Nawiązywanie połączenia z bazą danych JDBC ...................................................a........ 672
20.5. Przesyłanie zapytań JDBC i pobieranie wyników ...................................................a...... 675
20.6. Wykorzystanie sparametryzowanych poleceń JDBC ...................................................a. 678
20.7. Wykorzystanie procedur osadzonych w JDBC...................................................a........... 682
20.8. Modyfikacja danych przy użyciu obiektu ResultSet ...................................................a.. 683
20.9. Modyfikacja danych przy użyciu poleceń SQL ...................................................a.......... 685
20.10. Odnajdywanie metadanych JDBC...................................................a............................. 687
20.11. Program JDAdmin ...................................................a...................................................a. 693
Rozdział 21. XML ...................................................o............................................ 699
21.0. Wprowadzenie...................................................a...................................................a......... 699
21.1. Przekształcanie danych XML przy użyciu XSLT ...................................................a........ 702
21.2. Analiza składniowa XML przy użyciu API SAX ...................................................a........ 705
21.3. Analiza dokumentów XML przy użyciu modelu obiektów dokumentu (DOM).......... 708
21.4. Weryfikacja poprawności struktury przy wykorzystaniu DTD .................................... 710
21.5. Generowanie własnego kodu XML przy wykorzystaniu DOM.................................... 711
21.6. Program xml2mif...................................................a...................................................a..... 713
Rozdział 22. Java w aplikacjach rozproszonych — RMI ................................ 717
22.0. Wprowadzenie...................................................a...................................................a......... 717
22.1. Definiowanie kontraktu RMI ...................................................a...................................... 719
12
Spis treści
22.2. Klient RMI........................................a...................................................a........................... 721
22.3. Serwer RMI...................................................a...................................................a.............. 722
22.4. Uruchamianie aplikacji RMI w sieci ...................................................a........................... 725
22.5. Program — wywołania zwrotne RMI...................................................a......................... 726
22.6. Program RMIWatch...................................................a...................................................a. 730
Rozdział 23. Pakiety i ich tworzenie...................................................o.............. 737
23.0. Wprowadzenie...................................................a...................................................a......... 737
23.1. Tworzenie pakietu ...................................................a...................................................a... 738
23.2. Tworzenie dokumentacji klas przy użyciu programu Javadoc ..................................... 739
23.3. Stosowanie programu archiwizującego jar...................................................a................. 743
23.4. Uruchamianie apletu zapisanego w pliku JAR...................................................a........... 744
23.5. Wykonywanie apletu przy użyciu JDK...................................................a...................... 745
23.6. Uruchamianie programu zapisanego w pliku JAR...................................................a..... 749
23.7. Tworzenie klasy w taki sposób, by była komponentem JavaBean................................ 749
23.8. Umieszczanie komponentów w plikach JAR...................................................a.............. 753
23.9. Umieszczanie serwletów w plikach JAR...................................................a..................... 754
23.10. „Zapisz raz, instaluj wszędzie”...................................................a................................. 755
23.11. Java Web Start...................................................a...................................................a........ 756
23.12. Podpisywanie plików JAR ...................................................a........................................ 762
Rozdział 24. Stosowanie wątków w Javie...................................................o..... 765
24.0. Wprowadzenie...................................................a...................................................a......... 765
24.1. Uruchamianie kodu w innym wątku...................................................a.......................... 767
24.2. Animacja — wyświetlanie poruszających się obrazów ................................................. 771
24.3. Zatrzymywanie działania wątku ...................................................a................................ 775
24.4. Spotkania i ograniczenia czasowe...................................................a............................... 777
24.5. Komunikacja między wątkami — kod synchronizowany ............................................. 779
24.6. Komunikacja między wątkami — metody wait() oraz notifyAll() ................................ 785
24.7. Zapis danych w tle w programach edycyjnych ...................................................a.......... 791
24.8. Wielowątkowy serwer sieciowy ...................................................a................................. 792
Rozdział 25. Introspekcja lub „klasa o nazwie Class” .................................... 801
25.0. Wprowadzenie...................................................a...................................................a......... 801
25.1. Pobieranie deskryptora klasy ...................................................a..................................... 802
25.2. Określanie i stosowanie metod i pól..................................................a............................ 803
25.3. Dynamiczne ładowanie i instalowanie klas...................................................a................ 807
25.4. Tworzenie nowej klasy od podstaw ...................................................a........................... 809
25.5. Określanie efektywności działania...................................................a.............................. 811
Spis treści
13
25.6. Wyświetlanie informacji o klasie ...................................................a................................ 815
25.7. Program CrossRef...................................................a...................................................a.... 816
25.8. Program AppletViewer...................................................a............................................... 821
Rozdział 26. Wykorzystywanie Javy
wraz z innymi językami programowania.................................... 829
26.0. Wprowadzenie...................................................a...................................................a......... 829
26.1. Uruchamianie programu ...................................................a............................................ 830
26.2. Wykonywanie programu i przechwytywanie jego wyników ....................................... 833
26.3. Wykorzystanie BSF do łączenia kodu Javy i skryptów ................................................. 836
26.4. Dołączanie kodu rodzimego (C/C++)...................................................a........................ 841
26.5. Wywoływanie kodu Javy z kodu rodzimego...................................................a............. 847
26.6. Program DBM...................................................a...................................................a.......... 848
Posłowie ....................................................................................................................... 851
Skorowidz .................................................................................................................... 853
8
Techniki obiektowe
8.0. Wprowadzenie
Java jest językiem zorientowanym obiektowo, czerpiącym z tradycji takich języków jak
Simula-67, SmallTalk oraz C++. Składania Javy jest wzorowana na języku C++, natomiast
wykorzystywane w niej rozwiązania na języku SmallTalk. Interfejs programistyczny
(API) Javy został stworzony w oparciu o model obiektowy. Często są w nim wykorzy-
stywane wzorce projektowe (patrz książka „Java. Wzorce projektowe” wydana przez wy-
dawnictwo Helion) takie jak Factory (fabryka) oraz Delegate (delegat). Ich znajomość,
choć nie jest konieczna, na pewno pomoże w lepszym zrozumieniu działania API.
Rady lub mantry
Jest bardzo wiele drobnych porad, których mógłbym udzielić. Jest też kilka zagadnień,
które wciąż powracają podczas poznawania podstaw języka Java i później, na kolejnych
etapach nauki.
Wykorzystanie standardowego API
Na ten temat nigdy nie można powiedzieć zbyt dużo. Bardzo wiele zagadnień, z któ-
rymi się borykamy, zostało już rozwiązanych przez programistów firmy JavaSoft. Do-
bre poznanie API jest najlepszym sposobem uniknięcia syndromu „wyważania otwar-
tych drzwi” — czyli wymyślania podrzędnych substytutów doskonałych produktów,
z których w każdej chwili można skorzystać. Po części takie jest właśnie przeznaczenie
niniejszej książki — ochrona przed ponownym odkrywaniem rzeczy, które już zostały
stworzone. Jednym z takich przykładów może być interfejs programistyczny pozwalający
na tworzenie i wykorzystanie różnego rodzaju kolekcji, dostępny w pakiecie java.util
252
Rozdział 8. Techniki obiektowe
i opisany dokładniej w poprzednim rozdziale. Cechuje go wysoka uniwersalność i re-
gularność, dzięki czemu potrzeba tworzenia własnego kodu służącego do strukturali-
zacji danych jest bardzo mała.
Dążenie do ogólności
Istnieje pewien kompromis pomiędzy ogólnością (i wynikającymi z niej możliwościami
wielokrotnego używania kodu), na którą kładę nacisk w niniejszej książce, oraz wygodą,
jaką daje dostosowanie używanych rozwiązań do tworzonej aplikacji. Jeśli tworzymy
pewną niewielką część bardzo dużej aplikacji zaprojektowanej zgodnie z technikami
projektowania obiektowego, na pewno będziemy pamiętać o określonym zbiorze tak
zwanych przypadków zastosowania. Jednak z drugiej strony, jeśli będziemy pisać „pakiet
narzędziowy”, to warto tworzyć klasy, wykorzystując jak najmniej założeń co do przy-
szłych sposobów ich wykorzystania. Zapewnienie łatwości wykorzystania kodu w jak
największej ilości różnych programów jest najlepszym sposobem tworzenia kodu gwa-
rantującego możliwość wielokrotnego wykorzystania.
Czytanie i tworzenie dokumentacji (Javadoc)
Bez wątpienia Czytelnik przeglądał dokumentację Javy dostępną w formie dokumen-
tów HTML; częściowo zapewne dlatego, że poleciłem dobrze poznać standardowy in-
terfejs programistyczny. Czy firma Sun wynajęła tłumy pisarzy w celu stworzenia tej
dokumentacji? Otóż nie. Dokumentacja ta istnieje dzięki temu, iż twórcy Java API po-
święcili czas, aby pisać specjalne komentarze dokumentujące — te śmieszne wiesze za-
czynające się od znaków /**, które można zobaczyć w tak wielu przykładach. A za-
tem, jeszcze jedna rada: sami też używajmy tych komentarzy. Nareszcie dysponujemy
dobrym, standardowym mechanizmem służącym do dokumentowania tworzonych
interfejsów programistycznych. I jeszcze uwaga: komentarze te powinny być pisane
podczas tworzenia kodu — nie łudźmy się, że uda się napisać je później. W przyszło-
ści nigdy nie będzie na to czasu.
Szczegółowe informacje na temat tworzenia dokumentacji i wykorzystania programu
Javadoc można znaleźć w recepturze 23.2.
Klasy potomne powinny być tworzone jak najwcześniej i jak najczęściej
Także o tym wciąż należy przypominać. Tworzenie klas potomnych jest ze wszech miar
zalecane. Należy je tworzyć zawsze, kiedy mamy po temu okazję. To najlepszy sposób
nie tylko na uniknięcie powtarzania kodu, lecz także na tworzenie działających progra-
mów. Informacje na ten temat można znaleźć w wielu dobrych książkach poświęconych
technikom projektowania i programowania obiektowego. Wzorce projektowe stały się
ostatnio szczególnym przypadkiem „projektowania obiektowego przy jednoczesnym uni-
kaniu wymyślania już opracowanych rozwiązań”. Dlatego też połączyłem obie te rady.
Na początku warto zajrzeć do dobrej książki.
8.1. Wyświetlanie obiektów — formatowanie obiektów przy użyciu metody toString()
253
Korzystanie z wzorców projektowych
We Wstępie, w części zatytułowanej „Inne książki”, wymieniłem pozycję Java. Wzorce
projektowe, zaznaczając, iż jest to bardzo ważna praca o projektowaniu obiektowym,
gdyż zawiera wyczerpujący zbiór informacji o rozwiązaniach, które programiści często
wymyślają od nowa. Książka ta jest niezwykle istotna zarówno ze względu na to, że
tworzy standardowe słownictwo związane z projektowaniem, jak i dlatego, że w przy-
stępnej formie tłumaczy sposób działania prostych wzorców projektowych oraz poka-
zuje, jak można je zaimplementować.
Poniżej podałem kilka przykładów wykorzystania wzorców projektowych w standar-
dowym API języka Java.
Wzorzec projektowy
Znaczenie
Przykłady w Java API
Factory (fabryka)
Jedna klasa tworzy kopie obiektów
kontrolowane przez klasy potomne.
getInstance (w klasach
Calendar, Format,
Locale, ...); konstruktor gniazd;
Iterator oraz starszy interfejs
Enumeration
Iterator
Singleton
Memento
Command (polecenie)
Pobiera po kolei wszystkie elementy
kolekcji, przy czym każdy jest
pobierany tylko i wyłącznie raz.
Istnieje tylko jedna kopia obiektu.
java.awt.Toolkit
Pobiera i udostępnia stan obiektu,
tak aby można go było odtworzyć
później.
Hermetyzuje żądania, umożliwiając
tworzenie kolejek żądań, odtwarzanie
wykonywanych operacji i tak dalej.
serializacja obiektów
java.awt.Command
Model-View-Controler
(model-widok-kontroler)
Model reprezentuje dane, widok
określa to, co widzi użytkownik,
a kontroler odpowiada na żądania
użytkowników.
Observer/Observable;
patrz także
ServletDispatcher
(receptura 18.8)
8.1. Wyświetlanie obiektów — formatowanie
obiektów przy użyciu metody toString()
Problem
Chcemy, aby obiekty mogły być prezentowane w przydatny, intuicyjny sposób.
Rozwiązanie
Należy przesłonić metodę toString() odziedziczoną po obiekcie java.lang.Object.
254
Analiza
Rozdział 8. Techniki obiektowe
Za każdym razem, gdy obiekt zostanie przekazany w wywołaniu metody System.out.
println(), innej analogicznej metody lub użyty w konkatenacji łańcuchów znaków, Java
automatycznie wywoła jego metodę toString(). Java „wie”, że metodę toString() po-
siada każdy obiekt, gdyż posiada ją klasa java.lang.Object, a zatem, także wszystkie jej
klasy potomne. Domyślna implementacja tej metody użyta w klasie Object nie jest ani inte-
resująca, ani przydatna — wyświetla nazwę kasy, znak @ oraz wartość zwracaną przez me-
todę hashCode() (patrz receptura 8.3). Na przykład, jeśli wykonamy poniższy program:
/* Prezentacja metody toString() (bez przesłaniania). */
public class ToStringWithout {
int x, y;
/** Prosty konstruktor. */
public ToStringWithout(int anX, int aY) {
x = anX; y = aY;
}
/** Metoda main - tworzy i wyświetla obiekt. */
public static void main(String[] args) {
System.out.println(new ToStringWithout(42, 86));
}
}
przekonamy się, że generuje on niezbyt czytelne wyniki:
ToStringWithout@ad3ba4
A zatem, aby dane o obiekcie były prezentowane w lepszy sposób, we wszystkich,
oprócz najprostszych, klasach należy zaimplementować metodę toString(), która bę-
dzie wyświetlać nazwę klasy oraz jakieś ważne informacje na temat bieżącego stanu
obiektu. W ten sposób można uzyskać lepszą kontrolę nad sposobem formatowania in-
formacji o obiektach w metodzie println(), w programach uruchomieniowych oraz
wszędzie tam, gdzie odwołanie do obiektu występuje w kontekście łańcucha znaków.
Poniżej przedstawiłem zmodyfikowaną wersję poprzedniego programu, w której została
zaimplementowana metoda toString():
/* Prezentacja metody toString() (przesłoniętej). */
public class ToStringWith {
int x, y;
/** Prosty konstruktor. */
public ToStringWith(int anX, int aY) {
x = anX; y = aY;
}
/** Nowa wersja metody toString. */
public String toString() {
return ToStringWith[ + x + , + y + ] ;
}
/** Metoda main tworzy i wyświetla obiekt. */
public static void main(String[] args) {
System.out.println(new ToStringWith(42, 86));
}
}
8.2. Przesłanianie metody equals
255
Ta wersja programu wyświetla znacznie bardziej przydatne wyniki:
ToStringWith[42,86]
8.2. Przesłanianie metody equals
Problem
Chcemy mieć możliwość porównywania obiektów zdefiniowanej przez nas klasy.
Rozwiązanie
Należy stworzyć metodę equals().
Analiza
W jaki sposób określamy równość? W przypadku operatorów arytmetyczny lub logicz-
nych, odpowiedź na to pytanie jest prosta — wystarczy sprawdzić dwie wartości przy
użyciu operatora równości (==). Jednak w przypadku porównywania odwołań do
obiektów Java udostępnia dwa rozwiązania — operator == oraz metodę equals()
odziedziczoną po klasie java.lang.Object.
Operator równości może być nieco mylący, gdyż jego działanie sprowadza się do po-
równania dwóch odwołań i sprawdzenia, czy wskazują one ten sam obiekt.
Także odziedziczona metoda equals() nie jest aż tak przydatna, jak można by sobie
wyobrażać. Niektórzy zaczynają swoją karierę programistów używających Javy, sądząc,
że domyślna metoda equals() może dokonać jakiegoś magicznego porównania za-
wartości obiektów pole po polu, a nawet porównać je w sposób binarny. Niemniej jed-
nak metoda ta nie porównuje pól! Działa ona w najprostszy z możliwych sposobów —
zwraca wartość porównania dwóch obiektów przy użyciu operatora ==. A zatem, aby
móc wykonać jakąkolwiek przydatną operację, trzeba samemu stworzyć metodę equ-
als() odpowiednią dla danej klasy. Warto zauważyć, że zarówno metoda equals(),
jak i hashCode() są wykorzystywane przez tablice mieszające (klasy Hashtable oraz
HashMap, przedstawione w recepturze 7.6). A zatem, jeśli istnieje prawdopodobieństwo,
że inne osoby używające naszych klas mogą chcieć przechowywać je w tablicach mie-
szających lub tylko porównywać, to powinniśmy, zarówno ze względu na nich, jak i na
siebie, poprawnie zaimplementować metodę equals().
Poniżej przedstawiłem zasady działania tej metody:
1. Metoda equals() jest zwrotna, czyli x.equals(x) musi zwracać wartość true.
2. Metoda equals() jest symetryczna, czyli x.equals(y) musi zwrócić wartość
true wtedy i tylko wtedy, gdy y.equals(x) także zwraca wartość true.
256
Rozdział 8. Techniki obiektowe
3. Metoda equals() jest przechodnia, czyli jeśli x.equals(y) zwraca wartość true
oraz y.equals(z) także zwraca wartość true, to x.equals(z) także musi
zwracać wartość true.
4. Metoda jest spójna, czyli wielokrotne wywoływanie metody x.equals(y) zawsze
powinno zwracać tę samą wartość (chyba że zmieniły się zmienne określające stan
wykorzystywane przy porównywaniu obiektów).
5. Metoda musi być „ostrożna”, czyli wywołanie x.equals(null) musi zwracać
wartość false; nie może natomiast zgłaszać wyjątku NullPointerException.
Przedstawiona poniżej klasa stara się zaimplementować te zasady:
public class EqualsDemo {
int int1;
SomeClass obj1;
/** Konstruktor. */
public EqualsDemo(int i, SomeClass o) {
int1 = i;
obj1 = o;
}
public EqualsDemo() {
this(0, new SomeClass());
}
/** Najbardziej typowa implementacja metody equals(). */
public boolean equals(Object o) {
if (o == null) // Zabezpieczenie.
return false;
if (o == this) // Optymalizacja.
return true;
// Czy można rzutować do tej klasy?
if (!(o instanceof EqualsDemo))
return false;
EqualsDemo other = (EqualsDemo)o; // OK, można rzutować.
// Porównanie poszczególnych pól.
if (int1 != other.int1) // Typy proste porównujemy
bezpośrednio,
return false;
if (!obj1.equals(other.obj1)) // a obiekty przy użyciu metody equals()
return false;
return true;
}
}
Poniżej przedstawiłem program testowy junit (patrz receptura 1.13) dla klasy Equals-
Demo:
import junit.framework.*;
/** Przykładowe testy dla klasy EqualsDemo
* przeznaczone do wykorzystania z narzędziem junit
* stworzenie pełnego zbioru testów pozostawiam jako
* zadanie do samodzielnego wykonania dla Czytelnika.
* Sposób uruchamiania: $ java junit.textui.TestRunner EqualsDemoTest
8.3. Przesłanianie metody hashCode
257
* @version $Id: EqualsDemoTest.java,v 1.2 2002/06/20 20:25:03 ian Exp $
*/
public class EqualsDemoTest extends TestCase {
/** Testowany obiekt. */
EqualsDemo d1;
/** Inny testowany obiekt. */
EqualsDemo d2;
/** Metoda init(). */
public void setUp() {
d1 = new EqualsDemo();
d2 = new EqualsDemo();
}
/** Konstruktor używany przez junit. */
public EqualsDemoTest(String name) {
super(name);
}
public void testSymmetry() {
assertTrue(d1.equals(d1));
}
public void testSymmetric() {
assertTrue(d1.equals(d2) d2.equals(d1));
}
public void testCaution() {
assertTrue(!d1.equals(null));
}
}
Przy tak dokładnym przetestowaniu, czy jest jeszcze coś, co może w tej metodzie za-
wieść? Cóż, trzeba zadbać o kilka spraw. Co się stanie, jeśli obiekt przekazany w wy-
wołaniu będzie obiektem klasy potomnej klasy EqualsDemo? Wykonamy rzutowanie
i… porównamy wyłącznie pola przekazanego obiektu! Jeśli zatem możliwe jest opero-
wanie na obiektach klas potomnych, to prawdopodobnie trzeba będzie jawnie testować
obiekty przy użyciu metody getClass(). Obiekty klas potomnych powinny natomiast
wywoływać metodę super.equals(), aby sprawdzać wszystkie pola klasy bazowej.
Co jeszcze może zawieść? A co, jeśli jeden z obiektów, obj1 lub inny.obj1, będzie
równy null? W takim przypadku możemy zobaczyć śliczny komunikat o wyjątku
NullPointerException. A zatem, dodatkowo należy sprawdzać wszystkie miejsca,
gdzie mogą się pojawić wartości null. Problemów tego typu można uniknąć, tworząc
dobre konstruktory (co starałem się zrobić w klasie EqualsDemo) lub jawnie sprawdza-
jąc, czy gdzieś nie pojawiła się wartość null.
8.3. Przesłanianie metody hashCode
Problem
Chcemy wykorzystywać obiekty w tablicach mieszających i w tym celu musimy stwo-
rzyć metodę hashCode().
258
Analiza
Rozdział 8. Techniki obiektowe
Według założeń, metoda hashCode() ma zwracać liczbę całkowitą typu int, której
wartości będą w unikalny sposób identyfikować obiekty danej klasy.
Poprawnie napisana metoda hashCode() spełnia następujące założenia:
1. Jest powtarzalna — kilkukrotnie wywołana metoda x.hashCode() musi zwracać tę
samą wartość, chyba że w międzyczasie zmienił się stan obiektu.
2. Metoda hashCode() jest symetryczna, czyli: jeśli x.equals(y), to x.hashCode() ==
y.hashCode(); oba wyrażenia muszą zwracać bądź wartość true, bądź wartość false.
3. Nie ma reguły, która nakazuje, by w przypadku, gdy wywołanie x.equals(y)
zwraca wartość false, także wartości x.hashCode() oraz y.hashCode() były
od siebie różne. Niemniej jednak zapewnienie takiego właśnie działania metody
hashCode() może poprawić efektywność działania tablic mieszających; na przykład,
tablice mogą wywoływać metodę hashCode() przed wywołaniem metody equals().
Domyślna implementacja metody hashCode() wykorzystana w JDK firmy Sun zwraca
adres maszynowy i jest zgodna z przedstawioną powyżej zasadą 1. Zgodność z zasada-
mi 2. i 3., po części zależy od utworzonej metody equals(). Poniżej przedstawiłem
program wyświetlający kody mieszające kilku obiektów:
/** Wyświetla kody mieszające (zwracane przez metodę hashCode())
* kilku obiektów.
*/
public class PrintHashCodes {
/** Obiekty, dla których wyświetlimy kody mieszające. */
protected static Object[] data = {
new PrintHashCodes(),
new java.awt.Color(0x44, 0x88, 0xcc),
new SomeClass()
};
public static void main(String[] args) {
System.out.println( Obliczamy kod mieszający + data.length +
obiektów. );
for (int i=0; i data.length; i++) {
System.out.println(data[i].toString() + -- +
data[i].hashCode());
}
System.out.println( Gotowe. );
}
}
Jakie wyniki generuje powyższy program?
jikes +E -d . PrintHashCodes.java
java PrintHashCodes
Obliczamy kod mieszający 3 obiektów.
PrintHashCodes@7c6768 -- 8152936
java.awt.Color[r=68,g=136,b=204] -- -12285748
SomeClass@690726 -- 6883110
Gotowe.
8.4. Metoda clone
259
Interesująca jest wartość mieszająca dla obiektów klasy Color. Jest ona obliczana w na-
stępujący sposób:
(r 24 + g 16 + b 8 + alpha)
Najstarszy bit tego słowa uzyskany w wyniku przesunięcia powoduje, że w przypadku
wyświetlania tej wartości jako liczby całkowitej ze znakiem, jest ona wyświetlana jako
wartość ujemna. Nic nie stoi na przeszkodzie, by kody mieszające miały wartości ujemne.
8.4. Metoda clone
Problem
Chcemy się sklonować. No... przynajmniej nasze obiekty.
Rozwiązanie
Należy przesłonić metodę Object.clone().
Analiza
Sklonowanie oznacza zrobienie duplikatu. Metoda clone() dostępna w Javie tworzy do-
kładną kopię obiektu. Dlaczego mielibyśmy potrzebować takiej możliwości? Otóż w ję-
zyku Java argumenty wywołań metod są przekazywane przez odwołanie, dzięki czemu
wywoływana metoda może zmienić stan przekazanego do niej obiektu. Sklonowanie
obiektu przed wywołaniem metody, spowoduje przekazanie do niej kopii obiektu, dzięki
czemu jego oryginał będzie bezpieczny.
W jaki sposób można klonować obiekty? Możliwość klonowania nie jest domyślnie do-
stępna w tworzonych klasach.
Object o = new Object();
Object o2 = o.clone();
Próba wywołania metody clone() bez specjalnego przygotowania spowoduje wyświe-
tlenie stosownego komunikatu. Poniższy przykład przedstawia komunikat wygenero-
wany przez kompilator Jikes w przypadku próby skompilowania pliku Clone0.java (ko-
munikaty generowane przez kompilator javac mogą być mniej opisowe):
Clone0.java:4:29:4:37: Error: Method java.lang.Object clone(); in class
java/lang/Object has protected or default access. Therefore it is not
accessible in class Clone0 which is in a different package.
W celu zapewnienia możliwości klonowania obiektów tworzonej klasy, należy:
1. Przesłonić metodę
Pobierz darmowy fragment (pdf)
