Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00265 008600 10442129 na godz. na dobę w sumie
Java. Receptury - książka
Java. Receptury - książka
Autor: Liczba stron: 888
Wydawca: Helion Język publikacji: polski
ISBN: 83-7197-902-9 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook, audiobook).
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:

Książka 'Java. Receptury' jest idealną pozycją uzupełniającą dla programistów używających języka Java (lub książką podstawową dla osób, które Javy nauczyły się samodzielnie). Prezentuje ona wiele interfejsów programistycznych w sposób znacznie bardziej obszerny niż standardowe omówienie, dzięki czemu doskonale nadaje się dla osób potrzebujących szerszej znajomości Javy.

Ian F. Darwin ma trzydziestoletnie doświadczenia w tworzeniu oprogramowania i książek o programowaniu. Pracuje także jako instruktor oraz autor kursów w firmie Learning Tree Interanational.

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 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)

Gdzie kupić całą publikację:

Java. Receptury
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ą: