Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00388 007423 15355995 na godz. na dobę w sumie
Java. Receptury. Wydanie III - ebook/pdf
Java. Receptury. Wydanie III - ebook/pdf
Autor: Liczba stron: 872
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-9573-7 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook, audiobook).

Rozwiązania i przykłady dla programistów używających języka Java

Java to jeden z języków programowania najchętniej wybieranych do tworzenia zaawansowanych systemów informatycznych. Systemy bankowe, aukcyjne oraz inne zaawansowane programy wspomagające codzienną pracę tysięcy ludzi opierają się na Javie i narzędziach z nią związanych. Jeżeli chcesz śmiało wkroczyć w świat tego języka, musisz mieć tę książkę!

Książka należy do cenionej serii „Receptury”, która przedstawia różne zagadnienia w postaci krótkich przepisów. Nie inaczej jest w tym przypadku. Sięgnij po nią i zobacz, jak kompilować, uruchamiać i testować tworzony kod. W kolejnych rozdziałach zaznajomisz się z najlepszymi metodami przetwarzania ciągów znaków oraz nauczysz się korzystać z wyrażeń regularnych i wykonywać operacje na liczbach. Ponadto zdobędziesz dogłębną wiedzę na temat systemu wejścia-wyjścia, używania systemu plików, sieci oraz drukarek. Książka ta jest obowiązkową pozycją na półce każdego programisty Javy!

Przedstawione receptury obejmują: Najlepsze przepisy dla programistów Javy!
 

Ian F. Darwin - swoją przygodę w binarnym świecie rozpoczął w 1980 roku od pracy z systemem operacyjnym UNIX. Autor narzędzia file znanego z systemów Linux oraz BSD. Programista Javy od 1995 roku. Autor darmowych narzędzi: PassMaker, JpsTrack. Pracownik Learning Tree International — światowego lidera w zakresie organizacji kursów technicznych.
Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: Java Cookbook, Third Edition Tłumaczenie: Piotr Rajca ISBN: 978-83-246-9570-6 © 2015 Helion S.A. Authorized Polish translation of the English edition of Java Cookbook, ISBN 9781449337049 © 2014 RejmiNet Group, Inc. This translation is published and sold by permission of O’Reilly Media, Inc., which owns or controls all rights to publish and sell the same. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/jarec3 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/jarec3.zip Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis tre(cid:316)ci Wst(cid:253)p ........................................................................................................................... 13 1. Rozpoczynanie pracy: kompilacja, uruchamianie i testowanie ................................ 31 1.0. Wprowadzenie ............................................................................................................................. 31 1.1. Kompilacja i uruchamianie programów napisanych w Javie — JDK ................................ 32 1.2. Edycja i kompilacja programów przy u(cid:276)yciu edytorów wyposa(cid:276)onych w kolorowanie syntaktyczne ........................................................................ 33 1.3. Kompilacja, uruchamianie i testowanie programów przy u(cid:276)yciu IDE ............................. 35 1.4. Efektywne wykorzystanie zmiennej (cid:264)rodowiskowej CLASSPATH .................................. 42 1.5. Pobieranie przyk(cid:228)adów do(cid:228)(cid:241)czonych do tej ksi(cid:241)(cid:276)ki i korzystanie z nich ......................... 44 1.6. Automatyzacja kompilacji przy u(cid:276)yciu programu Ant ....................................................... 50 1.7. Automatyzacja zale(cid:276)no(cid:264)ci, kompilacji, testowania i wdra(cid:276)ania przy u(cid:276)yciu programu Apache Maven ................................................................................... 53 1.8. Automatyzacja zale(cid:276)no(cid:264)ci, kompilacji, testowania i wdra(cid:276)ania przy u(cid:276)yciu programu Gradle .................................................................................................. 56 1.9. Komunikaty o odrzuconych metodach ................................................................................... 59 1.10. Testowanie warunkowe bez u(cid:276)ycia dyrektywy #ifdef ....................................................... 61 1.11. Zapewnianie poprawno(cid:264)ci programu za pomoc(cid:241) asercji .................................................. 63 1.12. Wykorzystanie programu uruchomieniowego .................................................................... 64 1.13. Testowanie jednostkowe — jak unikn(cid:241)(cid:232) konieczno(cid:264)ci stosowania programów uruchomieniowych? ..................................................................... 66 1.14. Zarz(cid:241)dzanie kodem z wykorzystaniem ci(cid:241)g(cid:228)ej integracji .................................................. 69 1.15. Uzyskiwanie czytelnych komunikatów o wyj(cid:241)tkach ......................................................... 74 1.16. Poszukiwanie przyk(cid:228)adowych kodów (cid:274)ród(cid:228)owych: programy, szkielety i biblioteki ..... 74 2. Interakcja ze (cid:316)rodowiskiem ........................................................................................79 2.0. Wprowadzenie ............................................................................................................................. 79 2.1. Pobieranie warto(cid:264)ci zmiennych (cid:264)rodowiskowych ................................................................ 79 2.2. Pobieranie informacji z w(cid:228)a(cid:264)ciwo(cid:264)ci systemowych .............................................................. 81 2.3. Okre(cid:264)lanie u(cid:276)ywanej wersji JDK .............................................................................................. 82 2.4. Tworzenie kodu zale(cid:276)nego od u(cid:276)ywanego systemu operacyjnego ................................... 84 2.5. Stosowanie rozszerzaj(cid:241)cych interfejsów programistycznych lub innych API ................. 87 2.6. Analiza argumentów podanych w wierszu wywo(cid:228)ania programu ................................... 87 3 Kup książkęPoleć książkę 3. (cid:292)a(cid:295)cuchy znaków i przetwarzanie tekstów ...............................................................95 3.0. Wprowadzenie ............................................................................................................................. 95 3.1. Odczytywanie fragmentów (cid:228)a(cid:254)cucha ...................................................................................... 97 3.2. Dzielenie (cid:228)a(cid:254)cuchów na s(cid:228)owa .................................................................................................. 98 3.3. (cid:227)(cid:241)czenie (cid:228)a(cid:254)cuchów znaków przy u(cid:276)yciu klasy StringBuilder ........................................ 102 3.4. Przetwarzanie (cid:228)a(cid:254)cucha znaków po jednej literze .............................................................. 104 3.5. Wyrównywanie (cid:228)a(cid:254)cuchów znaków ..................................................................................... 105 3.6. Konwersja pomi(cid:246)dzy znakami Unicode a (cid:228)a(cid:254)cuchami znaków ....................................... 108 3.7. Odwracanie kolejno(cid:264)ci s(cid:228)ów lub znaków w (cid:228)a(cid:254)cuchu ........................................................ 110 3.8. Rozwijanie i kompresja znaków tabulacji ............................................................................. 111 3.9. Kontrola wielko(cid:264)ci liter ............................................................................................................ 116 3.10. Wcinanie zawarto(cid:264)ci dokumentów tekstowych ................................................................ 117 3.11. Wprowadzanie znaków niedrukowalnych ........................................................................ 118 3.12. Usuwanie odst(cid:246)pów z ko(cid:254)ca (cid:228)a(cid:254)cucha ............................................................................... 119 3.13. Przetwarzanie danych rozdzielonych przecinkami .......................................................... 120 3.14. Program — proste narz(cid:246)dzie do formatowania tekstów ................................................. 125 3.15. Program — fonetyczne porównywanie nazwisk .............................................................. 127 4. Dopasowywanie wzorców przy u(cid:348)yciu wyra(cid:348)e(cid:295) regularnych ................................131 4.0. Wprowadzenie ........................................................................................................................... 131 4.1. Sk(cid:228)adnia wyra(cid:276)e(cid:254) regularnych ............................................................................................... 133 4.2. Wykorzystanie wyra(cid:276)e(cid:254) regularnych w j(cid:246)zyku Java — sprawdzanie wyst(cid:246)powania wzorca ................................................................................ 140 4.3. Odnajdywanie tekstu pasuj(cid:241)cego do wzorca ....................................................................... 143 4.4. Zast(cid:246)powanie okre(cid:264)lonego tekstu .......................................................................................... 146 4.5. Wy(cid:264)wietlanie wszystkich wyst(cid:241)pie(cid:254) wzorca ....................................................................... 147 4.6. Wy(cid:264)wietlanie wierszy zawieraj(cid:241)cych fragment pasuj(cid:241)cy do wzorca .............................. 149 4.7. Kontrola wielko(cid:264)ci znaków w metodach match() i subst() ............................................... 150 4.8. Dopasowywanie znaków z akcentami lub znaków z(cid:228)o(cid:276)onych ........................................ 152 4.9. Odnajdywanie znaków nowego wiersza .............................................................................. 153 4.10. Program — analiza dziennika serwera Apache ................................................................. 155 4.11. Program — analizowanie danych ........................................................................................ 156 4.12. Program — pe(cid:228)na wersja programu grep ........................................................................... 159 5. Liczby ......................................................................................................................... 165 5.0. Wprowadzenie ........................................................................................................................... 165 5.1. Sprawdzanie, czy (cid:228)a(cid:254)cuch znaków stanowi poprawn(cid:241) liczb(cid:246) .......................................... 168 5.2. Zapisywanie du(cid:276)ych warto(cid:264)ci w zmiennych „mniejszych” typów ................................. 170 5.3. Konwertowanie liczb na obiekty i na odwrót ...................................................................... 171 5.4. Pobieranie u(cid:228)amka z liczby ca(cid:228)kowitej bez konwertowania go na posta(cid:232) zmiennoprzecinkow(cid:241) ............................................................................................. 172 5.5. Wymuszanie zachowania dok(cid:228)adno(cid:264)ci liczb zmiennoprzecinkowych ........................... 173 5.6. Porównywanie liczb zmiennoprzecinkowych ..................................................................... 175 4 (cid:95) Spis tre(cid:316)ci Kup książkęPoleć książkę 5.7. Zaokr(cid:241)glanie warto(cid:264)ci zmiennoprzecinkowych .................................................................. 177 5.8. Formatowanie liczb ................................................................................................................... 178 5.9. Konwersje pomi(cid:246)dzy ró(cid:276)nymi systemami liczbowymi — dwójkowym, ósemkowym, dziesi(cid:246)tnym i szesnastkowym ......................................... 181 5.10. Operacje na grupie liczb ca(cid:228)kowitych .................................................................................. 182 5.11. Pos(cid:228)ugiwanie si(cid:246) cyframi rzymskimi ................................................................................... 183 5.12. Formatowanie z zachowaniem odpowiedniej postaci liczby mnogiej .......................... 187 5.13. Generowanie liczb losowych ................................................................................................. 189 5.14. Obliczanie funkcji trygonometrycznych ............................................................................. 192 5.15. Obliczanie logarytmów .......................................................................................................... 192 5.16. Mno(cid:276)enie macierzy ................................................................................................................. 193 5.17. Operacje na liczbach zespolonych ........................................................................................ 195 5.18. Obs(cid:228)uga liczb o bardzo du(cid:276)ych warto(cid:264)ciach ...................................................................... 197 5.19. Program TempConverter ....................................................................................................... 200 5.20. Program — generowanie liczbowych palindromów ........................................................ 201 6. Daty i godziny — nowy interfejs programowania aplikacji ....................................205 6.0. Wprowadzenie ........................................................................................................................... 205 6.1. Okre(cid:264)lanie bie(cid:276)(cid:241)cej daty ........................................................................................................... 208 6.2. Wy(cid:264)wietlanie daty i czasu w zadanym formacie ................................................................ 209 6.3. Konwersja liczb okre(cid:264)laj(cid:241)cych dat(cid:246) i czas oraz ilo(cid:264)ci sekund ........................................... 211 6.4. Analiza (cid:228)a(cid:254)cuchów znaków i ich zamiana na daty ............................................................. 212 6.5. Obliczanie ró(cid:276)nic pomi(cid:246)dzy dwiema datami ...................................................................... 213 6.6. Dodawanie i odejmowanie dat ............................................................................................... 214 6.7. Stosowanie starych klas Date i Calendar .............................................................................. 215 7. Strukturalizacja danych w j(cid:253)zyku Java ......................................................................217 7.0. Wprowadzenie ........................................................................................................................... 217 7.1. Strukturalizacja danych przy u(cid:276)yciu tablic .......................................................................... 218 7.2. Modyfikacja wielko(cid:264)ci tablic ................................................................................................... 220 7.3. Szkielet kolekcji .......................................................................................................................... 221 7.4. Klasa podobna do tablicy, lecz bardziej dynamiczna ......................................................... 223 7.5. Stosowanie kolekcji ogólnych ................................................................................................. 225 7.6. Unikanie rzutowania dzi(cid:246)ki zastosowaniu typów ogólnych ............................................ 227 7.7. Jak przegl(cid:241)da(cid:232) zawarto(cid:264)(cid:232) kolekcji? Wyliczenie dost(cid:246)pnych sposobów .......................... 230 7.8. Unikanie powtórze(cid:254) dzi(cid:246)ki zastosowaniu zbioru ............................................................... 232 7.9. Iteratory lub wyliczenia — dost(cid:246)p do danych w sposób niezale(cid:276)ny od ich typów ..... 233 7.10. Strukturalizacja danych z wykorzystaniem list po(cid:228)(cid:241)czonych ......................................... 234 7.11. Odwzorowywanie z wykorzystaniem klas Hashtable oraz HashMap ......................... 238 7.12. Zapisywanie (cid:228)a(cid:254)cuchów znaków w obiektach Properties i Preferences ....................... 240 7.13. Sortowanie kolekcji ................................................................................................................. 244 7.14. Unikanie konieczno(cid:264)ci sortowania danych ........................................................................ 248 7.15. Odnajdywanie obiektu w kolekcji ........................................................................................ 250 Spis tre(cid:316)ci (cid:95) 5 Kup książkęPoleć książkę 7.16. Zamiana kolekcji na tablic(cid:246) ................................................................................................... 252 7.17. Tworzenie w(cid:228)asnego iteratora ............................................................................................... 253 7.18. Stos ............................................................................................................................................. 256 7.19. Struktury wielowymiarowe .................................................................................................. 259 7.20. Program — porównanie szybko(cid:264)ci dzia(cid:228)ania ..................................................................... 261 8. Techniki obiektowe ...................................................................................................263 8.0. Wprowadzenie ........................................................................................................................... 263 8.1. Wy(cid:264)wietlanie obiektów — formatowanie obiektów przy u(cid:276)yciu metody toString() ..... 266 8.2. Przes(cid:228)anianie metod equals() oraz hashCode() .................................................................... 267 8.3. Porz(cid:241)dki w aplikacji przy u(cid:276)yciu metody addShutdownHook() .................................... 273 8.4. Wykorzystanie klas wewn(cid:246)trznych ....................................................................................... 274 8.5. Tworzenie metod zwrotnych z wykorzystaniem interfejsów ........................................... 276 8.6. Polimorfizm i metody abstrakcyjne ....................................................................................... 279 8.7. Przekazywanie warto(cid:264)ci ........................................................................................................... 281 8.8. Warto(cid:264)ci wyliczeniowe bezpieczne dla typów .................................................................... 284 8.9. Wymuszanie u(cid:276)ycia wzorca Singleton .................................................................................. 288 8.10. Zg(cid:228)aszanie w(cid:228)asnych wyj(cid:241)tków ............................................................................................ 290 8.11. Wstrzykiwanie zale(cid:276)no(cid:264)ci ...................................................................................................... 291 8.12. Program Plotter ........................................................................................................................ 294 9. Techniki programowania funkcyjnego: interfejsy funkcyjne, strumienie i kolekcje równoleg(cid:293)e ...........................................299 9.0. Wprowadzenie ........................................................................................................................... 299 9.1. Stosowanie wyra(cid:276)e(cid:254) lambda lub domkni(cid:246)(cid:232) zamiast klas wewn(cid:246)trznych ...................... 301 9.2. Stosowanie predefiniowanych interfejsów lambda zamiast w(cid:228)asnych ........................... 304 9.3. Upraszczanie przetwarzania z wykorzystaniem interfejsu Stream ................................. 306 9.4. Poprawianie przepustowo(cid:264)ci dzi(cid:246)ki wykorzystaniu strumieni i kolekcji równoleg(cid:228)ych .... 308 9.5. Tworzenie w(cid:228)asnych interfejsów funkcyjnych ..................................................................... 309 9.6. U(cid:276)ywanie istniej(cid:241)cego kodu w sposób funkcyjny dzi(cid:246)ki wykorzystaniu odwo(cid:228)a(cid:254) do metod ............................................................................ 311 9.7. Wstawianie istniej(cid:241)cego kodu metod .................................................................................... 315 10. Wej(cid:316)cie i wyj(cid:316)cie .........................................................................................................317 10.0. Wprowadzenie ......................................................................................................................... 317 10.1. Odczytywanie informacji ze standardowego strumienia wej(cid:264)ciowego ........................ 320 10.2. Odczyt z konsoli lub okna terminala; odczyt has(cid:228)a bez jego wy(cid:264)wietlania ................. 323 10.3. Zapis danych w standardowym strumieniu wyj(cid:264)ciowym lub w strumieniu b(cid:228)(cid:246)dów .... 325 10.4. Wy(cid:264)wietlanie tekstów przy u(cid:276)yciu klasy Formatter i metody printf ............................ 327 10.5. Analiza zawarto(cid:264)ci pliku przy u(cid:276)yciu klasy StringTokenizer ........................................ 331 10.6. Analiza danych wej(cid:264)ciowych przy u(cid:276)yciu klasy Scanner ............................................... 335 10.7. Analiza danych wej(cid:264)ciowych o strukturze gramatycznej ................................................ 338 10.8. Otwieranie pliku o podanej nazwie ..................................................................................... 340 10.9. Kopiowanie plików ................................................................................................................. 341 6 (cid:95) Spis tre(cid:316)ci Kup książkęPoleć książkę 10.10. Odczytywanie zawarto(cid:264)ci pliku i zapisywanie jej w obiekcie String .......................... 347 10.11. Zmiana skojarze(cid:254) standardowych strumieni ................................................................... 347 10.12. Powielanie strumienia podczas realizacji operacji zapisu ............................................. 348 10.13. Odczyt i zapis danych zakodowanych w innym zbiorze znaków ............................... 351 10.14. Te k(cid:228)opotliwe znaki ko(cid:254)ca wiersza .................................................................................... 352 10.15. Kod operuj(cid:241)cy na plikach w sposób zale(cid:276)ny od systemu operacyjnego .................... 353 10.16. Odczytywanie „podzielonych” wierszy tekstu ............................................................... 354 10.17. Odczytywanie i zapisywanie danych binarnych ............................................................. 358 10.18. Przej(cid:264)cie do okre(cid:264)lonego miejsca w pliku ......................................................................... 359 10.19. Zapisywanie danych w strumieniu z wykorzystaniem j(cid:246)zyka C ................................ 360 10.20. Zapisywanie i odczytywanie obiektów ............................................................................. 363 10.21. Unikanie wyj(cid:241)tków ClassCastException spowodowanych nieprawid(cid:228)owymi warto(cid:264)ciami SerialVersionUID .......................................................... 366 10.22. Odczytywanie i zapisywanie danych w archiwach JAR oraz ZIP ............................... 368 10.23. Odnajdywanie plików w sposób niezale(cid:276)ny od systemu operacyjnego przy u(cid:276)yciu metod getResource() i getResourceAsStream() ......................................... 371 10.24. Odczytywanie i zapisywanie skompresowanych plików ............................................. 373 10.25. Poznawanie API do obs(cid:228)ugi portów szeregowych i równoleg(cid:228)ych ............................. 374 10.26. Zapisywanie danych u(cid:276)ytkownika na dysku .................................................................. 379 10.27. Program — zamiana tekstu do postaci PostScript .......................................................... 382 11. Operacje na katalogach i systemie plików ...............................................................387 11.0. Wprowadzenie ......................................................................................................................... 387 11.1. Pobieranie informacji o pliku ................................................................................................ 388 11.2. Tworzenie pliku ....................................................................................................................... 390 11.3. Zmiana nazwy pliku ............................................................................................................... 391 11.4. Usuwanie plików .................................................................................................................... 392 11.5. Tworzenie plików tymczasowych ........................................................................................ 394 11.6. Zmiana atrybutów pliku ........................................................................................................ 395 11.7. Tworzenie listy zawarto(cid:264)ci katalogu ................................................................................... 397 11.8. Pobieranie katalogów g(cid:228)ównych .......................................................................................... 399 11.9. Tworzenie nowych katalogów .............................................................................................. 400 11.10. Stosowanie klasy Path zamiast File ................................................................................... 401 11.11. Stosowanie us(cid:228)ugi WatchService do uzyskiwania informacji o zmianach pliku ...... 402 11.12. Program Find ......................................................................................................................... 404 12. Multimedia: grafika, d(cid:346)wi(cid:253)k i wideo ........................................................................407 12.0. Wprowadzenie ......................................................................................................................... 407 12.1. Rysowanie przy u(cid:276)yciu obiektu Graphics .......................................................................... 408 12.2. Testowanie komponentów graficznych .............................................................................. 409 12.3. Wy(cid:264)wietlanie tekstu ................................................................................................................ 410 12.4. Wy(cid:264)wietlanie wy(cid:264)rodkowanego tekstu w komponencie ................................................ 411 12.5. Rysowanie cienia ..................................................................................................................... 413 Spis tre(cid:316)ci (cid:95) 7 Kup książkęPoleć książkę 12.6. Wy(cid:264)wietlanie tekstu przy u(cid:276)yciu biblioteki grafiki dwuwymiarowej .......................... 415 12.7. Wy(cid:264)wietlanie tekstu przy u(cid:276)yciu czcionki aplikacji ......................................................... 417 12.8. Wy(cid:264)wietlanie obrazu .............................................................................................................. 419 12.9. Odczyt i zapis obrazów przy u(cid:276)yciu pakietu javax.imageio .......................................... 423 12.10. Odtwarzanie pliku d(cid:274)wi(cid:246)kowego ...................................................................................... 424 12.11. Prezentacja ruchomego obrazu ........................................................................................... 426 12.12. Drukowanie w Javie ............................................................................................................. 430 12.13. Program PlotterAWT ............................................................................................................ 434 12.14. Program Grapher ................................................................................................................... 435 13. Klienty sieciowe .........................................................................................................439 13.0. Wprowadzenie ......................................................................................................................... 439 13.1. Nawi(cid:241)zywanie po(cid:228)(cid:241)czenia z serwerem ............................................................................... 441 13.2. Odnajdywanie i zwracanie informacji o adresach sieciowych ....................................... 443 13.3. Obs(cid:228)uga b(cid:228)(cid:246)dów sieciowych .................................................................................................. 445 13.4. Odczyt i zapis danych tekstowych ...................................................................................... 446 13.5. Odczyt i zapis danych binarnych ......................................................................................... 448 13.6. Odczyt i zapis danych serializowanych .............................................................................. 450 13.7. Datagramy UDP ...................................................................................................................... 452 13.8. Program — klient TFTP wykorzystuj(cid:241)cy protokó(cid:228) UDP ................................................. 454 13.9. URI, URL czy mo(cid:276)e URN? ..................................................................................................... 458 13.10. Klient us(cid:228)ugi internetowej REST ......................................................................................... 459 13.11. Klient us(cid:228)ugi internetowej SOAP ....................................................................................... 461 13.12. Program — klient us(cid:228)ugi Telnet ......................................................................................... 466 13.13. Program — klient pogaw(cid:246)dek internetowych ................................................................. 468 13.14. Program — sprawdzanie odno(cid:264)ników HTTP .................................................................. 472 14. Graficzny interfejs u(cid:348)ytkownika ..............................................................................475 14.0. Wprowadzenie ......................................................................................................................... 475 14.1. Wy(cid:264)wietlanie komponentów graficznego interfejsu u(cid:276)ytkownika ................................ 477 14.2. Uruchamianie graficznego interfejsu u(cid:276)ytkownika w w(cid:241)tku przekazywania zdarze(cid:254) ........................................................................................ 478 14.3. Projektowanie uk(cid:228)adu okna ................................................................................................... 480 14.4. Karty — nowe spojrzenie na (cid:264)wiat ...................................................................................... 483 14.5. Obs(cid:228)uga czynno(cid:264)ci — tworzenie dzia(cid:228)aj(cid:241)cych przycisków ............................................. 484 14.6. Obs(cid:228)uga czynno(cid:264)ci z wykorzystaniem anonimowych klas wewn(cid:246)trznych ................. 486 14.7. Obs(cid:228)uga czynno(cid:264)ci z wykorzystaniem wyra(cid:276)e(cid:254) lambda ................................................. 488 14.8. Ko(cid:254)czenie programu przy u(cid:276)yciu przycisku Zamknij ..................................................... 489 14.9. Okna dialogowe — tego nie mo(cid:276)na zrobi(cid:232) pó(cid:274)niej .......................................................... 494 14.10. Przechwytywanie i formatowanie wyj(cid:241)tków graficznego interfejsu u(cid:276)ytkownika ... 496 14.11. Wy(cid:264)wietlanie wyników wykonania programu w oknie ................................................ 499 14.12. Wybieranie warto(cid:264)ci przy u(cid:276)yciu komponentu JSpinner .............................................. 505 14.13. Wybieranie plików przy u(cid:276)yciu klasy JFileChooser ....................................................... 506 8 (cid:95) Spis tre(cid:316)ci Kup książkęPoleć książkę 14.14. Wybieranie koloru ................................................................................................................. 509 14.15. Formatowanie komponentów przy u(cid:276)yciu kodu HTML .............................................. 511 14.16. Wy(cid:264)wietlanie okna g(cid:228)ównego po(cid:264)rodku ekranu ............................................................. 512 14.17. Zmiana sposobów prezentacji programów pisanych z wykorzystaniem pakietu Swing ...................................................................................... 515 14.18. Korzystanie z rozszerzonych mo(cid:276)liwo(cid:264)ci pakietu Swing w systemie Mac OS X ..... 519 14.19. Tworzenie aplikacji z graficznym interfejsem u(cid:276)ytkownika przy u(cid:276)yciu pakietu JavaFX ................................................................................................ 522 14.20. Program — w(cid:228)asne narz(cid:246)dzie do wybierania czcionek ................................................. 524 14.21. Program — w(cid:228)asny mened(cid:276)er uk(cid:228)adu ............................................................................... 528 15. Tworzenie programów wieloj(cid:253)zycznych oraz lokalizacja ......................................535 15.0. Wprowadzenie ......................................................................................................................... 535 15.1. Tworzenie przycisku w ró(cid:276)nych wersjach j(cid:246)zykowych ................................................... 535 15.2. Tworzenie listy dost(cid:246)pnych ustawie(cid:254) lokalnych .............................................................. 538 15.3. Tworzenie menu z wykorzystaniem zasobów wieloj(cid:246)zycznych .................................... 539 15.4. Tworzenie metod pomocniczych przydatnych podczas pisania programów wieloj(cid:246)zycznych .................................................................. 539 15.5. Tworzenie okien dialogowych z wykorzystaniem zasobów wieloj(cid:246)zycznych ............ 541 15.6. Tworzenie wi(cid:241)zki zasobów ................................................................................................... 543 15.7. Usuwanie (cid:228)a(cid:254)cuchów znaków z kodu ................................................................................ 544 15.8. Wykorzystanie konkretnych ustawie(cid:254) lokalnych ............................................................. 545 15.9. Okre(cid:264)lanie domy(cid:264)lnych ustawie(cid:254) lokalnych ..................................................................... 546 15.10. Formatowanie komunikatów przy u(cid:276)yciu klasy MessageFormat ............................... 547 15.11. Program MenuIntl ................................................................................................................. 549 15.12. Program BusCard .................................................................................................................. 551 16. Programy Javy dzia(cid:293)aj(cid:233)ce na serwerze — gniazda .................................................555 16.0. Wprowadzenie ......................................................................................................................... 555 16.1. Tworzenie serwera .................................................................................................................. 556 16.2. Zwracanie odpowiedzi ((cid:228)a(cid:254)cucha znaków b(cid:241)d(cid:274) danych binarnych) ............................ 558 16.3. Zwracanie informacji o obiektach ........................................................................................ 562 16.4. Obs(cid:228)uga wielu klientów ......................................................................................................... 563 16.5. Serwer obs(cid:228)uguj(cid:241)cy protokó(cid:228) HTTP ..................................................................................... 567 16.6. Zabezpieczanie serwera WWW przy u(cid:276)yciu SSL i JSSE .................................................. 570 16.7. Rejestracja operacji sieciowych ............................................................................................. 572 16.8. Rejestracja przez sie(cid:232) przy u(cid:276)yciu SLF4J ............................................................................ 574 16.9. Rejestracja przez sie(cid:232) przy u(cid:276)yciu log4j .............................................................................. 576 16.10. Rejestracja przez sie(cid:232) przy u(cid:276)yciu pakietu java.util.logging ......................................... 579 16.11. Znajdowanie interfejsów sieciowych ................................................................................. 581 16.12. Program — serwer pogaw(cid:246)dek w Javie ............................................................................ 582 Spis tre(cid:316)ci (cid:95) 9 Kup książkęPoleć książkę 17. Java i poczta elektroniczna .......................................................................................587 17.0. Wprowadzenie ......................................................................................................................... 587 17.1. Wysy(cid:228)anie poczty elektronicznej — wersja dzia(cid:228)aj(cid:241)ca w przegl(cid:241)darkach .................... 588 17.2. Wysy(cid:228)anie poczty elektronicznej — w(cid:228)a(cid:264)ciwe rozwi(cid:241)zanie ............................................ 592 17.3. Dodawanie mo(cid:276)liwo(cid:264)ci wysy(cid:228)ania poczty do programu dzia(cid:228)aj(cid:241)cego na serwerze .... 594 17.4. Wysy(cid:228)anie wiadomo(cid:264)ci MIME .............................................................................................. 599 17.5. Tworzenie ustawie(cid:254) poczty elektronicznej ........................................................................ 602 17.6. Odczytywanie poczty elektronicznej ................................................................................... 603 17.7. Program MailReaderBean ...................................................................................................... 608 17.8. Program MailClient ................................................................................................................. 611 18. Dost(cid:253)p do baz danych ............................................................................................... 621 18.0. Wprowadzenie ......................................................................................................................... 621 18.1. (cid:227)atwy dost(cid:246)p do bazy danych przy u(cid:276)yciu JPA oraz Hibernate ................................... 623 18.2. Konfiguracja i nawi(cid:241)zywanie po(cid:228)(cid:241)cze(cid:254) JDBC .................................................................... 628 18.3. Nawi(cid:241)zywanie po(cid:228)(cid:241)czenia z baz(cid:241) danych JDBC ............................................................... 631 18.4. Przesy(cid:228)anie zapyta(cid:254) JDBC i pobieranie wyników ............................................................. 634 18.5. Wykorzystanie przygotowanych polece(cid:254) JDBC ................................................................ 637 18.6. Wykorzystanie procedur osadzonych w JDBC .................................................................. 641 18.7. Modyfikacja danych przy u(cid:276)yciu obiektu ResultSet ........................................................ 641 18.8. Zapisywanie wyników w obiektach RowSet ..................................................................... 642 18.9. Modyfikacja danych przy u(cid:276)yciu polece(cid:254) SQL ................................................................. 644 18.10. Odnajdywanie metadanych JDBC ...................................................................................... 646 18.11. Program SQLRunner ............................................................................................................ 650 19. Przetwarzanie danych w formacie JSON ................................................................. 661 19.0. Wprowadzenie ......................................................................................................................... 661 19.1. Bezpo(cid:264)rednie generowanie danych w formacie JSON ..................................................... 663 19.2. Analiza i zapisywanie danych JSON przy u(cid:276)yciu pakietu Jackson ............................... 664 19.3. Analiza i zapis danych w formacie JSON przy u(cid:276)yciu pakietu org.json ...................... 665 20. XML ............................................................................................................................669 20.0. Wprowadzenie ......................................................................................................................... 669 20.1. Konwersja obiektów na dane XML przy u(cid:276)yciu JAXB .................................................... 672 20.2. Konwersja obiektów na dane XML przy u(cid:276)yciu serializatorów .................................... 675 20.3. Przekszta(cid:228)canie danych XML przy u(cid:276)yciu XSLT .............................................................. 676 20.4. Analiza sk(cid:228)adniowa XML przy u(cid:276)yciu API SAX .............................................................. 679 20.5. Analiza dokumentów XML przy u(cid:276)yciu modelu obiektów dokumentu (DOM) ....... 681 20.6. Odnajdywanie elementów XML przy u(cid:276)yciu XPath ........................................................ 684 20.7. Weryfikacja poprawno(cid:264)ci struktury z wykorzystaniem DTD ........................................ 686 20.8. Generowanie w(cid:228)asnego kodu XML z wykorzystaniem DOM i obiektów przekszta(cid:228)ce(cid:254) XML ............................................................................................. 689 20.9. Program xml2mif ..................................................................................................................... 691 10 (cid:95) Spis tre(cid:316)ci Kup książkęPoleć książkę 21. Pakiety i ich tworzenie ..............................................................................................693 21.0. Wprowadzenie ......................................................................................................................... 693 21.1. Tworzenie pakietu ................................................................................................................... 694 21.2. Tworzenie dokumentacji klas przy u(cid:276)yciu programu Javadoc ...................................... 696 21.3. Wi(cid:246)cej ni(cid:276) Javadoc — adnotacje i metadane ...................................................................... 700 21.4. Stosowanie programu archiwizuj(cid:241)cego jar ......................................................................... 701 21.5. Uruchamianie programu zapisanego w pliku JAR ........................................................... 703 21.6. Tworzenie klasy w taki sposób, by by(cid:228)a komponentem JavaBeans ............................... 704 21.7. Umieszczanie komponentów w plikach JAR ..................................................................... 708 21.8. Umieszczanie serwletów w plikach JAR ............................................................................. 709 21.9. „Zapisz raz, instaluj wsz(cid:246)dzie” ............................................................................................ 710 21.10. „Napisz raz, instaluj na Mac OS X” ................................................................................... 711 21.11. Java Web Start ........................................................................................................................ 713 21.12. Podpisywanie plików JAR ................................................................................................... 719 22. Stosowanie w(cid:233)tków w Javie .....................................................................................721 22.0. Wprowadzenie ......................................................................................................................... 721 22.1. Uruchamianie kodu w innym w(cid:241)tku .................................................................................. 723 22.2. Animacja — wy(cid:264)wietlanie poruszaj(cid:241)cych si(cid:246) obrazów .................................................... 728 22.3. Zatrzymywanie dzia(cid:228)ania w(cid:241)tku .......................................................................................... 732 22.4. Spotkania i ograniczenia czasowe ........................................................................................ 734 22.5. Synchronizacja w(cid:241)tków przy u(cid:276)yciu s(cid:228)owa kluczowego synchronized ....................... 735 22.6. Upraszczanie synchronizacji przy u(cid:276)yciu blokad ............................................................. 741 22.7. Komunikacja mi(cid:246)dzy w(cid:241)tkami — metody wait() oraz notifyAll() ................................ 745 22.8. Upraszczanie programu producent-konsument przy u(cid:276)yciu interfejsu Queue .......... 750 22.9. Optymalizacja dzia(cid:228)ania równoleg(cid:228)ego przy u(cid:276)yciu Fork/Join ..................................... 753 22.10. Zapis danych w tle w programach edycyjnych ............................................................... 756 22.11. Wielow(cid:241)tkowy serwer sieciowy ......................................................................................... 758 22.12. Upraszczanie serwerów z wykorzystaniem klas pakietu java.util.concurrent .......... 765 23. Introspekcja lub „klasa o nazwie Class” ...................................................................769 23.0. Wprowadzenie ......................................................................................................................... 769 23.1. Pobieranie deskryptora klasy ................................................................................................ 770 23.2. Okre(cid:264)lanie oraz stosowanie metod i pól ............................................................................. 771 23.3. Uzyskiwanie dost(cid:246)pu do prywatnych pól i metod za pomoc(cid:241) introspekcji ................ 774 23.4. Dynamiczne (cid:228)adowanie i instalowanie klas ....................................................................... 775 23.5. Tworzenie nowej klasy od podstaw przy u(cid:276)yciu obiektu ClassLoader ....................... 778 23.6. Okre(cid:264)lanie efektywno(cid:264)ci dzia(cid:228)ania ....................................................................................... 779 23.7. Wy(cid:264)wietlanie informacji o klasie .......................................................................................... 784 23.8. Wy(cid:264)wietlanie klas nale(cid:276)(cid:241)cych do pakietu .......................................................................... 785 23.9. Stosowanie i definiowanie adnotacji ................................................................................... 787 23.10. Zastosowanie adnotacji do odnajdywania klas pe(cid:228)ni(cid:241)cych rol(cid:246) wtyczek ................... 792 23.11. Program CrossRef ................................................................................................................. 794 23.12. Program AppletViewer ........................................................................................................ 796 Spis tre(cid:316)ci (cid:95) 11 Kup książkęPoleć książkę 24. Wykorzystywanie Javy wraz z innymi j(cid:253)zykami programowania ..........................803 24.0. Wprowadzenie ......................................................................................................................... 803 24.1. Uruchamianie zewn(cid:246)trznego programu ............................................................................. 804 24.2. Wykonywanie programu i przechwytywanie jego wyników ......................................... 808 24.3. Wywo(cid:228)ywanie kodu napisanego w innych j(cid:246)zykach przy u(cid:276)yciu javax.script ........... 811 24.4. Tworzenie w(cid:228)asnego mechanizmu skryptowego .............................................................. 813 24.5. (cid:227)(cid:241)czenie j(cid:246)zyków Java i Perl ................................................................................................. 817 24.6. Do(cid:228)(cid:241)czanie kodu rodzimego ................................................................................................. 820 24.7. Wywo(cid:228)ywanie kodu Javy z kodu rodzimego .................................................................... 825 Pos(cid:293)owie .....................................................................................................................829 A Java kiedy(cid:316) i obecnie ................................................................................................. 831 Skorowidz ..................................................................................................................849 12 (cid:95) Spis tre(cid:316)ci Kup książkęPoleć książkę ROZDZIA(cid:292) 9. Techniki programowania funkcyjnego: interfejsy funkcyjne, strumienie i kolekcje równoleg(cid:293)e 9.0. Wprowadzenie (cid:130) Java jest j(cid:246)zykiem programowania obiektowego. Doskonale o tym wiemy. Obecnie coraz wi(cid:246)k- szym zainteresowaniem cieszy si(cid:246) programowanie funkcyjne (ang. functional programming, FP). By(cid:232) mo(cid:276)e nie ma a(cid:276) tak wielu definicji programowania funkcyjnego jak j(cid:246)zyków, które umo(cid:276)- liwiaj(cid:241) stosowanie tego stylu programowania, cho(cid:232) ich liczba mo(cid:276)e by(cid:232) podobna. A oto co na temat programowania funkcyjnego napisano w Wikipedii: „(…) paradygmat programowania, styl tworzenia struktury i elementów programów kompute- rowych, traktuj(cid:241)cy obliczenia jako przetwarzanie funkcji matematycznych i unikaj(cid:241)cy przecho- wywania stanu oraz danych podlegaj(cid:241)cych zmianom. Programowanie funkcyjne k(cid:228)adzie nacisk na funkcje, których wyniki zale(cid:276)(cid:241) wy(cid:228)(cid:241)cznie od danych wej(cid:264)ciowych, a nie od stanu programu, innymi s(cid:228)owy, na funkcje o charakterze matematycznym. Jest to paradygmat programowania deklaratywnego, co oznacza, (cid:276)e programowanie bazuje na wykorzystaniu wyra(cid:276)e(cid:254). W kodzie funkcyjnym wyniki zwracane przez funkcj(cid:246) s(cid:241) zale(cid:276)ne wy(cid:228)(cid:241)cznie od przekazanych do niej ar- gumentów, a zatem dwukrotne wywo(cid:228)anie funkcji f z tym samym argumentem x w obu przy- padkach spowoduje zwrócenie tego samego wyniku f(x). Wyeliminowanie efektów ubocznych, takich jak zmiany stanu, które nie zale(cid:276)(cid:241) od danych przekazanych do funkcji, znacznie u(cid:228)atwia zrozumienie i okre(cid:264)lenie sposobu dzia(cid:228)ania programu i stanowi jeden z kluczowych powodów rozwoju programowania funkcyjnego (…)”. — http://en.wikipedia.org/wiki/Functional_programming z pa(cid:274)dziernika 2014 W jaki sposób mo(cid:276)emy wykorzysta(cid:232) zasady programowania funkcyjnego? Jednym z nich mog(cid:228)oby by(cid:232) u(cid:276)ycie odpowiedniego funkcyjnego j(cid:246)zyka programowania, a do wiod(cid:241)cych j(cid:246)zyków tego typu nale(cid:276)(cid:241) Haskell OCaml, Erlang oraz rodzina j(cid:246)zyków LISP. Jednak wy- maga(cid:228)oby to odej(cid:264)cia z ekosystemu j(cid:246)zyka Java. Mo(cid:276)na by si(cid:246) ewentualnie zastanowi(cid:232) nad wykorzystaniem j(cid:246)zyków Scala (http://www.scala-lang.org/) lub Clojure (http://clojure.org/), które dzia(cid:228)aj(cid:241) w oparciu o wirtualn(cid:241) maszyn(cid:246) Javy i zapewniaj(cid:241) wsparcie dla programowania funk- cyjnego w kontek(cid:264)cie j(cid:246)zyka obiektowego. 299 Kup książkęPoleć książkę Jednak niniejsza ksi(cid:241)(cid:276)ka jest po(cid:264)wi(cid:246)cona Javie, zatem mo(cid:276)na sobie wyobrazi(cid:232), (cid:276)e b(cid:246)dziemy d(cid:241)(cid:276)y(cid:232) do skorzystania z zalet, jakie daje programowanie funkcyjne z wykorzystaniem wy- (cid:228)(cid:241)cznie tego j(cid:246)zyka. Do cech programowania funkcyjnego nale(cid:276)(cid:241): (cid:120) Funkcje czyste (ang. pure functions), czyli funkcje, które nie maj(cid:241) (cid:276)adnych efektów ubocz- nych i których wyniki zale(cid:276)(cid:241) wy(cid:228)(cid:241)cznie od przekazanych argumentów, a nie od stanu programu, który mo(cid:276)e ulega(cid:232) zmianom. (cid:120) Funkcje pierwszej klasy, czyli mo(cid:276)liwo(cid:264)(cid:232) traktowania funkcji jako danych. (cid:120) Dane niezmienne. (cid:120) Cz(cid:246)ste stosowanie rekurencji i przetwarzania leniwego. Funkcje czyste s(cid:241) ca(cid:228)kowicie niezale(cid:276)ne; ich dzia(cid:228)anie zale(cid:276)y wy(cid:228)(cid:241)cznie od przekazanych danych wej(cid:264)ciowych oraz ich wewn(cid:246)trznej logiki, a nie od zmiennego „stanu” innych cz(cid:246)(cid:264)ci programu — w rzeczywisto(cid:264)ci w programowaniu funkcyjnym nie ma czego(cid:264) takiego jak „zmienne glo- balne”, a jedynie „sta(cid:228)e globalne”. Cho(cid:232) dla osób przyzwyczajonych do stosowania j(cid:246)zyków imperatywnych, takich jak Java, mo(cid:276)e to by(cid:232) sporym zaskoczeniem, to jednak takie rozwi(cid:241)za- nia mog(cid:241) znacznie u(cid:228)atwi(cid:232) testowanie programów oraz zapewnienie prawid(cid:228)owo(cid:264)ci ich dzia(cid:228)ania! Oznacza to bowiem, (cid:276)e niezale(cid:276)nie do tego, co si(cid:246) dzieje w pozosta(cid:228)ych cz(cid:246)(cid:264)ciach programu (nawet w niezale(cid:276)nie dzia(cid:228)aj(cid:241)cych w(cid:241)tkach), wywo(cid:228)anie metody, takie jak computeValue(27), zawsze i bezwarunkowo zwróci t(cid:246) sam(cid:241) warto(cid:264)(cid:232) (wyj(cid:241)tkami s(cid:241) tu funkcje zwracaj(cid:241)ce ele- menty stanu globalnego, np. aktualn(cid:241) dat(cid:246) i godzin(cid:246), warto(cid:264)(cid:232) losow(cid:241) itd.). W tym rozdziale terminów funkcja oraz metoda b(cid:246)d(cid:246) u(cid:276)ywa(cid:228) wymiennie, cho(cid:232) zapewne nie jest to do ko(cid:254)ca poprawne. Osoby zwi(cid:241)zane z programowaniem funkcyjnym u(cid:276)ywaj(cid:241) terminu „funkcja”, maj(cid:241)c na my(cid:264)li matematyczn(cid:241) definicj(cid:246) funkcji, natomiast w j(cid:246)zyku Java „metody” s(cid:241) jedynie „kodem, który mo(cid:276)na wywo(cid:228)a(cid:232)” (z obiektowego punktu widzenia „wywo(cid:228)anie metody” w Javie okre(cid:264)la si(cid:246) tak(cid:276)e jako przes(cid:228)anie sygna(cid:228)u do obiektu). „Traktowanie funkcji jako danych” oznacza, (cid:276)e mo(cid:276)na utworzy(cid:232) obiekt b(cid:246)d(cid:241)cy funkcj(cid:241), prze- kaza(cid:232) go do innej funkcji, napisa(cid:232) funkcj(cid:246), która b(cid:246)dzie zwraca(cid:232) inn(cid:241) funkcj(cid:246), i tak dalej — a to wszystko bez konieczno(cid:264)ci stosowania jakiejkolwiek szczególnej sk(cid:228)adni, gdy(cid:276) funkcje s(cid:241) danymi. Jednym z rozwi(cid:241)za(cid:254) wprowadzonych w nowej wersji j(cid:246)zyka — Java 8 — maj(cid:241)cym na celu udost(cid:246)pnienie mo(cid:276)liwo(cid:264)ci programowania funkcyjnego s(cid:241) „interfejsy funkcyjne”. Interfejsem funkcyjnym w Javie nazywamy interfejs, który definiuje tylko jedn(cid:241) metod(cid:246). Przyk(cid:228)adami ta- kich interfejsów mog(cid:241) by(cid:232) bardzo popularny interfejs Runnable definiuj(cid:241)cy metod(cid:246) run() oraz powszechnie u(cid:276)ywany w bibliotece Swing interfejs ActionListener, który definiuje metod(cid:246) actionPerformed(ActionEvent). Okazuje si(cid:246), (cid:276)e tak(cid:276)e te nowe interfejsy j(cid:246)zyka Java 8 mog(cid:241) po- siada(cid:232) metody zadeklarowane za pomoc(cid:241) s(cid:228)owa kluczowego default, którego u(cid:276)ycie w tym kontek(cid:264)cie jest nowo(cid:264)ci(cid:241). Takie domy(cid:264)lne metody staj(cid:241) si(cid:246) dost(cid:246)pne i mog(cid:241) by(cid:232) u(cid:276)ywane w ka(cid:276)- dej klasie implementuj(cid:241)cej dany interfejs. Je(cid:264)li si(cid:246) nad tym zastanowimy, to stanie si(cid:246) jasne, (cid:276)e dzia(cid:228)anie takich metod nie mo(cid:276)e zale(cid:276)e(cid:232) od stanu konkretnej klasy, gdy(cid:276) nie mia(cid:228)yby one mo(cid:276)liwo(cid:264)ci odwo(cid:228)ania si(cid:246) do tego stanu w czasie kompilacji programu. A zatem nieco precyzyjniej rzecz ujmuj(cid:241)c, interfejs funkcyjny jest interfejsem definiuj(cid:241)cym jedn(cid:241), niedomy(cid:264)ln(cid:241) metod(cid:246). W j(cid:246)zyku Java mo(cid:276)na korzysta(cid:232) z funkcyjnego stylu programo- wania, je(cid:264)li zastosujemy interfejsy funkcyjne oraz je(cid:264)li kod umieszczany w metodach b(cid:246)dzie korzysta(cid:228) wy(cid:228)(cid:241)cznie ze sfinalizowanych zmiennych oraz pól obiektów. Jednym ze sposobów spe(cid:228)nienia tych wymaga(cid:254) jest korzystanie z metod domy(cid:264)lnych. Kilka pierwszych receptur tego rozdzia(cid:228)u jest po(cid:264)wi(cid:246)conych w(cid:228)a(cid:264)nie interfejsom funkcyjnym. 300 (cid:95) Rozdzia(cid:293) 9. Techniki programowania funkcyjnego: interfejsy funkcyjne, strumienie i kolekcje równoleg(cid:293)e Kup książkęPoleć książkę Kolejnym nowym rozwi(cid:241)zaniem umo(cid:276)liwiaj(cid:241)cym stosowanie funkcyjnego stylu programo- wania s(cid:241) „wyra(cid:276)enia lambda”. Lambda to wyra(cid:276)enie, którego typem jest interfejs funkcyjny i które mo(cid:276)e by(cid:232) u(cid:276)ywane jako dana (czyli mo(cid:276)na je przypisywa(cid:232) zmiennym lub zwraca(cid:232) jako wynik wywo(cid:228)ania metody itd.). Poni(cid:276)ej poda(cid:228)em dwa krótkie przyk(cid:228)ady wyra(cid:276)e(cid:254) lambda. ActionListener x = (e - System.out.println( Uaktywniono + e.getSource()); public class RunnableLambda { public static void main(String[] args) { new Thread(() - System.out.println( Witam w w(cid:200)tku )).start(); } } Kolejn(cid:241) nowo(cid:264)ci(cid:241) wprowadzon(cid:241) w Java 8 s(cid:241) klasy Stream. Przypominaj(cid:241) one nieco potok, w którym mo(cid:276)na co(cid:264) umie(cid:264)ci(cid:232), nast(cid:246)pnie wykona(cid:232) na nim jakie(cid:264) operacje, po czym przeka- za(cid:232) jego zawarto(cid:264)(cid:232) dalej — czyli co(cid:264), co mo(cid:276)na by uzna(cid:232) za po(cid:228)(cid:241)czenie uniksowych potoków oraz opracowanego przez Google modelu programowania rozproszonego MapReduce (któ- rego przyk(cid:228)adem mo(cid:276)e by(cid:232) projekt Hadoop, http://hadoop.apache.org/), lecz dzia(cid:228)aj(cid:241)ce w obr(cid:246)bie jednej wirtualnej maszyny Javy, czyli jednego programu. Obiekty Stream mog(cid:241) dzia(cid:228)a(cid:232) szere- gowo lub równolegle; przy czym te drugie zosta(cid:228)y zaprojektowane w celu wykorzystania mo(cid:276)- liwo(cid:264)ci przetwarzania równoleg(cid:228)ego, jakie zapewniaj(cid:241) platformy sprz(cid:246)towe (zw(cid:228)aszcza serwery, które bardzo cz(cid:246)sto s(cid:241) wyposa(cid:276)ane w procesory dysponuj(cid:241)ce dwunastoma lub szesnastoma rdzeniami). Tak(cid:276)e klasom Stream po(cid:264)wi(cid:246)ci(cid:228)em kilka receptur zamieszczonych w tym rozdziale. Z klasami Stream powi(cid:241)zany jest interfejs Spliterator, stanowi(cid:241)cy pochodn(cid:241) (pod wzgl(cid:246)dem logicznym, a nie dziedziczenia) iteratorów, lecz zaprojektowany w celu wykorzystania w prze- twarzaniu równoleg(cid:228)ym. Wi(cid:246)kszo(cid:264)(cid:232) osób nie b(cid:246)dzie musia(cid:228)a tworzy(cid:232) w(cid:228)asnych implementacji tego interfejsu, a nawet nie b(cid:246)dzie musia(cid:228)a zbyt cz(cid:246)sto jawnie wywo(cid:228)ywa(cid:232) jego metod, dlatego te(cid:276) nie po- (cid:264)wi(cid:246)c(cid:246) mu w tej ksi(cid:241)(cid:276)ce wiele uwagi. Patrz tak(cid:348)e Ogólne informacje na temat programowania funkcyjnego mo(cid:276)na znale(cid:274)(cid:232) w ksi(cid:241)(cid:276)ce Functional Thinking (http://shop.oreilly.com/product/0636920029687.do). Dost(cid:246)pna jest tak(cid:276)e ksi(cid:241)(cid:276)ka Richarda Warburtona Java 8 Lambdas (http://shop.oreilly.com/product/ 0636920030713.do), która zosta(cid:228)a w ca(cid:228)o(cid:264)ci po(cid:264)wi(cid:246)cona wyra(cid:276)eniom lambda oraz zwi(cid:241)zanym z nimi narz(cid:246)dziom. 9.1. Stosowanie wyra(cid:348)e(cid:295) lambda lub domkni(cid:253)(cid:235) zamiast klas wewn(cid:253)trznych (cid:130) Problem Chcemy unikn(cid:241)(cid:232) pisania rozbudowanego kodu, którego wymaga stosowanie klas wewn(cid:246)trznych. Rozwi(cid:233)zanie Nale(cid:276)y skorzysta(cid:232) z wyra(cid:276)e(cid:254) lambda. 9.1. Stosowanie wyra(cid:348)e(cid:295) lambda lub domkni(cid:253)(cid:235) zamiast klas wewn(cid:253)trznych (cid:95) 301 Kup książkęPoleć książkę Analiza Symbol lambda ((cid:540)) to jedenasta litera alfabetu greckiego, a zatem jest on tak stary jak ca(cid:228)a cywilizacja zachodnioeuropejska. Rachunek lambda (http://pl.wikipedia.org/wiki/Rachunek_lambda) jest równie stary jak sama informatyka. W tym kontek(cid:264)cie wyra(cid:276)enia lambda s(cid:241) niewielkimi fragmentami oblicze(cid:254), do których mo(cid:276)na si(cid:246) odwo(cid:228)ywa(cid:232). S(cid:241) one funkcjami, które mo(cid:276)na traktowa(cid:232) jako dane. W tym sensie s(cid:241) one bardzo podobne do anonimowych funkcji wewn(cid:246)trznych, cho(cid:232) chyba lepszym rozwi(cid:241)zaniem by(cid:228)oby wyobra(cid:276)enie ich sobie jako anonimowych metod. S(cid:241) one zasadniczo stosowane jako zamienniki klas wewn(cid:246)trznych w kodzie wykorzystuj(cid:241)- cym interfejsy funkcyjne — czyli interfejsy definiuj(cid:241)ce tylko jedn(cid:241) metod(cid:246) („funkcj(cid:246)”). Dosko- na(cid:228)ym przyk(cid:228)adem takiego interfejsu funkcyjnego jest ActionListener, powszechnie stosowany w kodzie obs(cid:228)ugi interfejsu u(cid:276)ytkownika. Interfejs ten definiuje tylko jedn(cid:241) metod(cid:246): public void actionPerformed(ActionEvent); Przyk(cid:228)ady wykorzystania wyra(cid:276)e(cid:254) lambda w obs(cid:228)udze interfejsu u(cid:276)ytkownika mo(cid:276)na znale(cid:274)(cid:232) w rozdziale 14. Poni(cid:276)ej, aby rozbudzi(cid:232) zainteresowanie Czytelnika, zamie(cid:264)ci(cid:228)em jeden z nich: quitButton.addActionListener(e - System.exit(0)); Jednak obecnie ju(cid:276) nie wszyscy tworz(cid:241) aplikacje z graficznym interfejsem u(cid:276)ytkownika, dlate- go zaczn(cid:246) od przyk(cid:228)adu, który nie jest z nimi w (cid:276)aden sposób zwi(cid:241)zany. Za(cid:228)ó(cid:276)my, (cid:276)e dyspo- nujemy zbiorem obiektów deskryptorów aparatów fotograficznych, które zosta(cid:228)y ju(cid:276) wczytane z bazy danych i zapisane w pami(cid:246)ci, a teraz chcemy napisa(cid:232) interfejs programistyczny ogólnego przeznaczenia pozwalaj(cid:241)cy na ich przeszukiwanie, którego mogliby(cid:264)my u(cid:276)ywa(cid:232) w pozosta(cid:228)ych miejscach naszej aplikacji. Pierwszym pomys(cid:228)em mog(cid:228)oby by(cid:232) stworzenie nast(cid:246)puj(cid:241)cego interfejsu: public interface CameraInfo { public List Camera findByMake(); public List Camera findByModel(); ... } Jednak by(cid:232) mo(cid:276)e Czytelnik ju(cid:276) zauwa(cid:276)y(cid:228) problem wi(cid:241)(cid:276)(cid:241)cy si(cid:246) z takim rozwi(cid:241)zaniem. Otó(cid:276) wraz ze zwi(cid:246)kszaniem si(cid:246) stopnia z(cid:228)o(cid:276)ono(cid:264)ci naszej aplikacji konieczne by(cid:228)oby tak(cid:276)e zaim- plementowanie metod findByPrice(), findByMakeAndModel(), findByYearIntroduced() i tak dalej. Mo(cid:276)na by sobie wyobrazi(cid:232) metod(cid:246) „znajd(cid:274) na podstawie przyk(cid:228)adu”, do której by(cid:228)by prze- kazywany obiekt Camera, a metoda odnajdywa(cid:228)aby inne obiekty, u(cid:276)ywaj(cid:241)c do porównania wszystkich
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

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