Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00581 008235 10457834 na godz. na dobę w sumie
Thinking in Java. Wydanie 3. Edycja polska - książka
Thinking in Java. Wydanie 3. Edycja polska - książka
Autor: Liczba stron: 912
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-133-9 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook, audiobook).

Doskonały podręcznik programowania obiektowego
w najważniejszym języku ery internetu

Książka 'Thinking in Java' wzbudziła entuzjazm i uznanie programistów na całym świecie przede wszystkim dzięki swej wyjątkowej przejrzystości, przemyślanej i uważnej organizacji oraz krótkim, trafnie dobranym przykładom. Książka obejmuje szeroki zakres tematów -- zaczynając od podstaw składni Javy, a kończąc na najbardziej zaawansowanych zagadnieniach (dokładny opis pojęć obiektowych, wielowątkowości, zautomatyzowane konstruowanie, testowanie modułów oraz wykrywanie i usuwanie błędów).

O autorze:
Bruce Eckel jest prezesem MindView, Inc., firmy prowadzącej zarówno otwarte jak i zamknięte kursy treningowe; zajmującej się też doradztwem, nadzorem i kontrolą nad projektami związanymi z technologiami obiektowymi i wzorcami projektowymi. [więcej...\

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

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Thinking in Java. Wydanie 3. Edycja polska Autor: Bruce Eckel T³umaczenie: Adrian Nowak, Szymon Kobalczyk, £ukasz Fryz ISBN: 83-7361-133-9 Format: B5, stron: 912 Ksi¹¿ka „Thinking in Java” wzbudzi³a entuzjazm i uznanie programistów na ca³ym ġwiecie przede wszystkim dziêki swej wyj¹tkowej przejrzystoġci, przemyġlanej i uwa¿nej organizacji oraz krótkim, trafnie dobranym przyk³adom. Ksi¹¿ka obejmuje szeroki zakres tematów — zaczynaj¹c od podstaw sk³adni Javy, a koñcz¹c na najbardziej zaawansowanych zagadnieniach (dok³adny opis pojêæ obiektowych, wielow¹tkowoġci, zautomatyzowane konstruowanie, testowanie modu³ów oraz wykrywanie i usuwanie b³êdów). • Wprowadzenie do jêzyka Java uaktualnione o prezentacjê nowych mo¿liwoġci wprowadzonych w JDK 1.4 • Nowy program testowy weryfikuj¹cy poprawnoġæ dzia³ania ka¿dego z programów i prezentuj¹cy generowane przez niego wyniki • Nowy rozdzia³ poġwiêcony testowaniu modu³ów, zautomatyzowanemu konstruowaniu programów, asercjom, rejestracji oraz innym sposobom zapewniania poprawnoġci programów • Ca³kowicie zmodyfikowany rozdzia³ poġwiêcony wielow¹tkowoġci pozwalaj¹cy dobrze poznaæ podstawy tego zagadnienia • Ponad 350 dzia³aj¹cych przyk³adów uaktualnionych z myġl¹ o niniejszym wydaniu ksi¹¿ki; ponad 15 tysiêcy wierszy kodu • Ksi¹¿ka zarówno dla pocz¹tkuj¹cych, jak i ekspertów • Uczy jêzyka Java, a nie rozwi¹zañ zale¿nych od platformy systemowej • Szczegó³owo omawia podstawowe zagadnienia, nie pomija bardziej zaawansowanych • Dog³êbnie wyjaġnia zasady obiektowoġci oraz ich zastosowanie w Javie Bruce Eckel jest prezesem MindView, Inc., firmy prowadz¹cej zarówno otwarte jak i zamkniête kursy treningowe; zajmuj¹cej siê te¿ doradztwem, nadzorem i kontrol¹ nad projektami zwi¹zanymi z technologiami obiektowymi i wzorcami projektowymi. Jest autorem ksi¹¿ki „Thinking in C++” oraz wspó³autorem ksi¹¿ek „Thinking in C#” oraz „Thinking in C++, Volume 2”, napisa³ tak¿e kilka innych ksi¹¿ek i ponad 150 artyku³ów. Od ponad 20 lat prowadzi wyk³ady i seminaria na ca³ym ġwiecie. By³ cz³onkiem Komitetu Standardów C++. Zdoby³ tytu³ naukowy w dziedzinie fizyki stosowanej i in¿ynierii oprogramowania. Spis treści Podziękowania ...................................................n................................... 17 Przedmowa...................................................n......................................... 21 Przedmowa do wydania trzeciego................................................... ..........................................23 Java 2, JDK 1.4 ................................................... ................................................... ...................25 Wprowadzenie ...................................................n.................................... 27 Warunki wstępne..................................... ................................................... ...............................27 Nauka Javy................................................... ................................................... ..........................28 Cele ................................................... ................................................... .....................................29 Dokumentacja online ................................................... ................................................... ..........29 Zawartość rozdziałów ................................................... ................................................... .........30 Ćwiczenia................................................... ................................................... ............................35 Kody źródłowe................................................... ................................................... ....................35 Konwencje zapisu................................................... ................................................... .........37 Wersje Javy ................................................... ................................................... .........................37 Błędy ................................................... ................................................... ...................................37 Projekt okładki ................................................... ................................................... ....................38 Rozdział 1. Wprowadzenie w świat obiektów...................................................n......... 39 Postępująca abstrakcja ................................................... ................................................... ........40 Obiekt posiada interfejs ................................................... ................................................... ......41 Obiekt dostarcza usług ................................................... ................................................... ........44 Ukrywanie implementacji ................................................... ................................................... ...45 Wielokrotne wykorzystanie implementacji ................................................... ...........................46 Dziedziczenie: wielokrotne użycie interfejsu ................................................... ........................47 „Bycie czymś” a „bycie podobnym do czegoś” ................................................... ..............50 Wymienialność obiektów z użyciem polimorfizmu ................................................... ..............51 Abstrakcyjne klasy bazowe i interfejsy ................................................... ...........................54 Tworzenie obiektów, sposób ich stosowania i czas życia ................................................... .....55 Kolekcje i iteratory ................................................... ................................................... .......56 Hierarchia z pojedynczym korzeniem ................................................... .............................57 Rzutowanie w dół kontra wzorce (generalia) ................................................... ..................58 Zapewnienie odpowiedniego „sprzątania” ................................................... ......................59 Obsługa wyjątków — eliminowanie błędów ................................................... .........................60 Współbieżność ................................................... ................................................... ....................61 Trwałość................................................... ................................................... ..............................62 Java i Internet ................................................... ................................................... ......................63 Czym jest Internet? ................................................... ................................................... .......63 Programowanie po stronie klienta ................................................... ...................................64 6 Thinking in Java. Edycja polska Programowanie po stronie serwera................................................... ..................................70 Aplikacje................................................... ................................................... .......................71 Dlaczego Java odnosi sukcesy ................................................... ...............................................71 Systemy jest łatwiej opisać i zrozumieć ................................................... ..........................71 Maksymalne zwiększenie wydajności dzięki bibliotekom.................................................72 Obsługa błędów ................................................... ................................................... ............72 Programowanie na wielką skalę ................................................... ......................................72 Java kontra C++ ................................................... ................................................... ..................73 Podsumowanie ................................................... ................................................... ....................74 Rozdział 2. Wszystko jest obiektem...................................................n...................... 75 Dostęp do obiektów poprzez referencje................................................... .................................75 Wszystkie obiekty trzeba stworzyć................................................... ........................................76 Gdzie przechowujemy dane................................................... .............................................77 Przypadek specjalny: typy podstawowe ................................................... ..........................78 Tablice w Javie ................................................... ................................................... .............79 Nigdy nie ma potrzeby niszczenia obiektu ................................................... ............................80 Zasięg................................................... ................................................... ............................80 Zasięg obiektów................................................... ................................................... ............81 Tworzenie nowych typów danych — klasa ................................................... ...........................82 Pola i metody ................................................... ................................................... ................82 Metody, argumenty i wartości zwracane ................................................... ...............................84 Lista argumentów ................................................... ................................................... .........85 Tworzenie programu w Javie................................................... .................................................86 Widoczność nazw ................................................... ................................................... .........86 Wykorzystanie innych komponentów ................................................... .............................86 Słowo kluczowe static ................................................... ................................................... ..87 Twój pierwszy program w Javie ................................................... ............................................89 Kompilacja i uruchomienie................................................... ..............................................90 Komentarze oraz dokumentowanie kodu................................................... ...............................91 Dokumentacja w komentarzach................................................... .......................................91 Składnia ................................................... ................................................... ........................92 Osadzony HTML ................................................... ................................................... ..........93 Niektóre znaczniki dokumentacyjne................................................... ................................93 Przykład dokumentowania kodu................................................... ......................................96 Styl programowania ................................................... ................................................... ............96 Podsumowanie ................................................... ................................................... ....................97 Ćwiczenia................................................... ................................................... ............................97 Rozdział 3. Sterowanie kolejnością wykonania ...................................................n...... 99 Używanie operatorów Javy................................................... ................................................... .99 Kolejność ................................................... ................................................... ....................100 Przypisanie................................................... ................................................... ..................100 Operatory matematyczne ................................................... ...............................................103 Operatory zwiększania i zmniejszania................................................... ...........................106 Operatory relacji ................................................... ................................................... .........107 Operatory logiczne................................................... ................................................... ......109 Operatory bitowe ................................................... ................................................... ........111 Operatory przesunięcia ................................................... ..................................................112 Operator trójargumentowy if-else................................................... ..................................115 Przecinek................................................... ................................................... .....................116 Łańcuchowy operator + ................................................... .................................................116 Najczęstsze pułapki przy używaniu operatorów................................................... ............117 Operatory rzutowania ................................................... ................................................... .117 W Javie nie ma „sizeof” ................................................... ................................................120 Rozdział 4. Spis treści 7 Powtórka z kolejności operatorów................................................... .................................120 Kompendium operatorów ................................................... ..............................................121 Sterowanie wykonaniem ................................................... ................................................... ...129 Prawda i fałsz................................................... ................................................... ..............129 if-else ................................................... ................................................... ..........................129 return................................................... ................................................... ...........................130 Iteracja ................................................... ................................................... ........................131 do-while ................................................... ................................................... ......................132 for................................................... ................................................... ................................132 break i continue................................................... ................................................... ...........134 switch................................................... ................................................... ..........................139 Podsumowanie ................................................... ................................................... ..................143 Ćwiczenia................................................... ................................................... ..........................143 Inicjalizacja i sprzątanie...................................................n.................... 145 Gwarantowana inicjalizacja przez konstruktor ................................................... ....................145 Przeciążanie metod ................................................... ................................................... ...........147 Rozróżnianie przeciążonych metod................................................... ...............................150 Przeciążanie a typy podstawowe ................................................... ...................................150 Przeciążanie przez wartości zwracane................................................... ...........................155 Konstruktory domyślne ................................................... .................................................155 Słowo kluczowe this ................................................... ................................................... ...156 Sprzątanie: finalizacja i odśmiecanie pamięci ................................................... .....................159 Do czego służy finalize() ................................................... ...............................................160 Musisz przeprowadzić sprzątanie ................................................... ..................................161 Warunek zakończenia................................................... ................................................... .162 Jak działa odśmiecacz pamięci ................................................... ......................................163 Inicjalizacja składowych ................................................... ................................................... ...166 Określanie sposobu inicjalizacji ................................................... ....................................167 Inicjalizacja w konstruktorze................................................... .........................................168 Inicjalizacja tablic ................................................... ................................................... .............174 Tablice wielowymiarowe................................................... ...............................................179 Podsumowanie ................................................... ................................................... ..................182 Ćwiczenia................................................... ................................................... ..........................182 Rozdział 5. Ukrywanie implementacji ...................................................n.................. 185 Pakiet — jednostka biblioteczna................................................... ..........................................186 Tworzenie unikatowych nazw pakietów ................................................... .......................188 Własna biblioteka narzędziowa ................................................... .....................................191 Wykorzystanie instrukcji import do zmiany zachowania.................................................192 Pułapka związana z pakietami ................................................... .......................................192 Modyfikatory dostępu w Javie................................................... .............................................192 Dostęp pakietowy ................................................... ................................................... .......193 public: dostęp do interfejsu................................................... ............................................194 private: nie dotykać! ................................................... ................................................... ...195 protected: dostęp „na potrzeby” dziedziczenia................................................... ..............196 Interfejs i implementacja................................................... ................................................... ...198 Dostęp do klas................................................... ................................................... ...................199 Podsumowanie ................................................... ................................................... ..................202 Ćwiczenia................................................... ................................................... ..........................203 Rozdział 6. Wielokrotne wykorzystanie klas ...................................................n........ 205 Składnia kompozycji................................................... ................................................... .........205 Składnia dziedziczenia................................................... ................................................... ......208 Inicjalizacja klasy bazowej ................................................... ............................................210 8 Thinking in Java. Edycja polska Łączenie kompozycji i dziedziczenia ................................................... ..................................212 Zapewnienie poprawnego sprzątania................................................... .............................214 Ukrywanie nazw ................................................... ................................................... .........217 Wybór między kompozycją a dziedziczeniem................................................... .....................218 protected................................................... ................................................... ............................220 Przyrostowe tworzenie oprogramowania................................................... .............................221 Rzutowanie w górę.................................... ................................................... ...........................222 Dlaczego „w górę”................................................... ................................................... ......223 Słowo kluczowe final................................................... ................................................... ........224 Zmienne finalne ................................................... ................................................... ..........224 Metody finalne................................................... ................................................... ............227 Klasy finalne................................................... ................................................... ...............230 Ostrożnie z deklaracją final ................................................... ...........................................230 Inicjalizacja i ładowanie klas ................................................... ...............................................231 Inicjalizacja w przypadku dziedziczenia ................................................... .......................232 Podsumowanie ................................................... ................................................... ..................233 Ćwiczenia................................................... ................................................... ..........................233 Rozdział 7. Polimorfizm ...................................................n...................................... 237 Rzutowanie w górę raz jeszcze ................................................... ............................................237 Zapominanie o typie obiektu ................................................... .........................................239 Mały trik................................................... ................................................... ............................240 Wiązanie wywołania metody................................................... .........................................241 Uzyskiwanie poprawnego działania ................................................... ..............................241 Rozszerzalność ................................................... ................................................... ...........244 Pułapka: „przesłanianie” metod prywatnych................................................... .................246 Klasy i metody abstrakcyjne ................................................... ................................................247 Konstruktory a polimorfizm................................................... .................................................250 Kolejność wywołań konstruktorów ................................................... ...............................250 Dziedziczenie a sprzątanie................................................... .............................................252 Zachowanie się metod polimorficznych wewnątrz konstruktorów ..................................255 Projektowanie z użyciem dziedziczenia ................................................... ..............................257 Czyste dziedziczenie kontra rozszerzanie ................................................... .....................259 Rzutowanie w dół a identyfikacja typu w czasie wykonania ...........................................260 Podsumowanie ................................................... ................................................... ..................262 Ćwiczenia................................................... ................................................... ..........................262 Rozdział 8. Interfejsy i klasy wewnętrzne ...................................................n............ 265 Interfejsy ................................................... ................................................... ...........................265 „Wielokrotne dziedziczenie” w Javie................................................... ............................268 Rozszerzanie interfejsu poprzez dziedziczenie ................................................... .............271 Grupowanie stałych ................................................... ................................................... ....272 Inicjalizacja pól interfejsów................................................... ...........................................274 Zagnieżdżanie interfejsów ................................................... .............................................275 Klasy wewnętrzne ................................................... ................................................... .............277 Klasy wewnętrzne a rzutowanie w górę ................................................... ........................279 Klasy wewnętrzne w metodach i zasięgach................................................... ...................280 Anonimowe klasy wewnętrzne................................................... ......................................282 Połączenie z klasą zewnętrzną................................................... .......................................286 Klasy zagnieżdżone ................................................... ................................................... ....288 Odwoływanie się do obiektu klasy zewnętrznej................................................... ............290 Sięganie na zewnątrz z klasy wielokrotnie zagnieżdżonej ...............................................290 Dziedziczenie po klasach wewnętrznych ................................................... ......................291 Czy klasy wewnętrzne mogą być przesłaniane ................................................... .............292 Lokalne klasy wewnętrzne ................................................... ............................................293 Identyfikatory klas wewnętrznych................................................... .................................295 Spis treści 9 Dlaczego klasy wewnętrzne................................................... .................................................296 Domknięcia i wywołania zwrotne ................................................... .................................298 Klasy wewnętrzne a szkielety sterowania ................................................... .....................300 Podsumowanie ................................................... ................................................... ..................306 Ćwiczenia................................................... ................................................... ..........................306 Rozdział 9. Obsługa błędów za pomocą wyjątków...................................................n 309 Podstawy obsługi wyjątków................................................... .................................................310 Parametry wyjątków ................................................... ................................................... ...311 Przechwytywanie wyjątku ................................................... ................................................... 312 Blok try ................................................... ................................................... .......................312 Obsługa wyjątków ................................................... ................................................... ......312 Tworzenie własnych wyjątków................................................... ............................................314 Specyfikacja wyjątków ................................................... ................................................... .....317 Przechwytywanie dowolnego wyjątku................................................... .................................318 Ponowne wyrzucanie wyjątków ................................................... ....................................320 Sekwencje wyjątków ................................................... ................................................... ..323 Standardowe wyjątki Javy ................................................... ................................................... 326 Specjalny przypadek RuntimeException................................................... .......................326 Robienie porządków w finally ................................................... .............................................328 Do czego służy finally ................................................... ................................................... 329 Pułapka: zagubiony wyjątek ................................................... ..........................................331 Ograniczenia wyjątków................................ ................................................... ........................332 Konstruktory ................................................... ................................................... .....................335 Dopasowywanie wyjątków ................................................... ..................................................338 Rozwiązania alternatywne ................................................... ................................................... 339 Historia ................................................... ................................................... .......................341 Perspektywy................................................... ................................................... ................342 Przekazywanie wyjątków na konsolę ................................................... ............................345 Zamiana wyjątków sprawdzanych na niesprawdzane ................................................... ...345 Wskazówki................................................... ................................................... ........................347 Podsumowanie ................................................... ................................................... ..................348 Ćwiczenia................................................... ................................................... ..........................348 Rozdział 10. Wykrywanie typów...................................................n............................ 351 Potrzeba mechanizmu RTTI ................................................... ................................................351 Obiekt Class................................................... ................................................... ................354 Sprawdzanie przed rzutowaniem................................................... ...................................356 Składnia RTTI................................................... ................................................... ...................366 Refleksje — informacja o klasie w czasie wykonania................................................... .........368 Ekstraktor metod klasowych................................................... ..........................................369 Podsumowanie ................................................... ................................................... ..................373 Ćwiczenia................................................... ................................................... ..........................374 Rozdział 11. Kolekcje obiektów ...................................................n............................ 375 Tablice................................................... ................................................... ...............................375 Tablice to obiekty ................................................... ................................................... .......376 Tablice jako wartości zwracane................................................... .....................................379 Klasa Arrays ................................................... ................................................... ...............381 Wypełnianie tablicy ................................................... ................................................... ....387 Kopiowanie tablic................................................... ................................................... .......389 Porównywanie tablic ................................................... ................................................... ..390 Porównywanie elementów tablic................................................... ...................................391 Sortowanie tablic ................................................... ................................................... ........394 Przeszukiwanie tablicy posortowanej................................................... ............................395 Podsumowanie wiadomości o tablicach ................................................... ........................397 10 Thinking in Java. Edycja polska Wprowadzenie do kontenerów................................................... .............................................397 Wypisanie zawartości kontenerów ................................................... ................................398 Wypełnianie kontenerów ................................................... ...............................................400 Wada kontenera: nieznany typ................................................... .............................................405 Czasami mimo wszystko działa................................................... .....................................407 Tworzenie świadomej typu klasy ArrayList................................................... ..................408 Iteratory................................................... ................................................... .............................410 Rodzaje kontenerów................................................... ................................................... ..........413 Interfejs Collection................................................... ................................................... ............416 Interfejs List ................................................... ................................................... ......................418 Stos na podstawie LinkedList................................................... ........................................422 Kolejka na podstawie LinkedList ................................................... ..................................423 Interfejs Set ................................................... ................................................... .......................423 SortedSet................................................... ................................................... .....................426 Możliwości funkcjonalne interfejsu Map ................................................... ............................427 SortedMap................................................... ................................................... ...................431 LinkedHashMap ................................................... ................................................... .........433 Haszowanie i kody haszujące ................................................... ........................................434 Przesłonięcie metody hashCode()................................................... ..................................443 Przechowywanie referencji ................................................... ..................................................446 WeakHashMap ................................................... ................................................... ...........449 Iteratory ponownie ................................................... ................................................... ............450 Wybór implementacji................................................... ................................................... ........451 Wybór między listami................................................... ................................................... .452 Wybór implementacji zbioru ................................................... .........................................454 Wybór implementacji odwzorowania................................................... ............................456 Sortowanie i przeszukiwanie list................................................... ..........................................459 Dodatkowe usługi ................................................... ................................................... .............460 Niemodyfikowalne kontenery Collection i Map ................................................... ...........462 Synchronizacja Collection i Map................................................... ...................................463 Nieobsługiwane operacje ................................................... ................................................... ..464 Kontenery Java 1.0 i 1.1........................... ................................................... ............................466 Vector i Enumeration................................................... ................................................... ..467 Hashtable ................................................... ................................................... ....................468 Stack ................................................... ................................................... ...........................468 BitSet ................................................... ................................................... ..........................469 Podsumowanie ................................................... ................................................... ..................470 Ćwiczenia................................................... ................................................... ..........................471 Rozdział 12. System wejścia-wyjścia w Javie ...................................................n........ 477 Klasa File ................................................... ................................................... ..........................477 Wypisywanie zawartości katalogu ................................................... ................................478 Operacje na katalogach................................................... ..................................................481 Wejście i wyjście ................................................... ................................................... ..............483 Typy InputStream ................................................... ................................................... .......483 Typy OutputStream ................................................... ................................................... ....484 Dodawanie atrybutów i użytecznych interfejsów ................................................... ................485 Czytanie z InputStream za pomocą FilterInputStream................................................... ..486 Zapis do OutputStream za pomocą FilterOutputStream................................................... 486 Klasy Reader i Writer ................................................... ................................................... .......488 Źródła i ujścia danych................................................... ................................................... .489 Modyfikacja zachowania strumienia ................................................... .............................489 Klasy niezmienione ................................................... ................................................... ....490 Osobna i samodzielna RandomAccessFile ................................................... ..........................491 Spis treści 11 Typowe zastosowania strumieni I/O................................................... ....................................491 Strumienie wejścia................................................... ................................................... ......493 Strumienie wyjścia................................................... ................................................... ......495 Strumienie typu „pipe” ................................................... ..................................................497 Narzędzia do zapisu i odczytu danych z plików ................................................... ..................497 Standardowe wejście-wyjście ................................................... ..............................................498 Czytanie ze standardowego wejścia ................................................... ..............................499 Zamiana System.out na PrintWriter ................................................... ..............................499 Przekierowywanie standardowego wejścia-wyjścia................................................... ......500 Nowe wejście-wyjście................................... ................................................... .......................501 Konwersja danych ................................................... ................................................... ......505 Pobieranie podstawowych typów danych................................................... ......................508 Widoki buforów................................................... ................................................... ..........509 Manipulowanie danymi przy użyciu buforów................................................... ...............514 Szczegółowe informacje o buforach................................................... ..............................515 Pliki odwzorowywane w pamięci................................................... ..................................518 Blokowanie plików................................................... ................................................... .....521 Kompresja ................................................... ................................................... .........................524 Prosta kompresja do formatu GZIP ................................................... ...............................524 Przechowywanie wielu plików w formacie Zip ................................................... ............525 Archiwa Javy (JAR) ................................................... ................................................... ...528 Serializacja obiektów ................................................... ................................................... ........529 Odnajdywanie klasy................................................... ................................................... ....533 Kontrola serializacji................................................... ................................................... ....534 Stosowanie trwałości ................................................... ................................................... ..542 Preferencje ................................................... ................................................... ........................547 Wyrażenia regularne ................................................... ................................................... .........549 Tworzenie wyrażeń regularnych................................................... ....................................549 Kwantyfikatory ................................................... ................................................... ...........551 Klasy Pattern oraz Matcher ................................................... ...........................................552 metoda split() ................................................... ................................................... ..............559 Operacje zastępowania ................................................... ..................................................560 Metoda reset()................................................... ................................................... .............562 Wyrażenia regularne i operacje wejścia-wyjścia Javy ................................................... ..563 Czy klasa StringTokenizer jest potrzebna ................................................... .....................564 Podsumowanie ................................................... ................................................... ..................565 Ćwiczenia................................................... ................................................... ..........................565 Rozdział 13. Współbieżność...................................................n.................................. 569 Motywacja................................................... ................................................... .........................570 Proste wątki................................................... ................................................... .......................571 Przełączanie ................................................... ................................................... ................573 Wstrzymywanie wykonywania wątku................................................... ...........................574 Priorytet ................................................... ................................................... ......................576 Wątki demony................................................... ................................................... .............578 Łączenie wątków ................................................... ................................................... ........580 Różne sposoby kodowania ................................................... ............................................582 Tworzenie wrażliwego interfejsu użytkownika................................................... .............587 Współdzielenie ograniczonych zasobów ................................................... .............................588 Niewłaściwy dostęp do zasobów ................................................... ...................................589 Kolizje podczas dostępu do zasobów ................................................... ............................593 Rozwiązywanie współzawodnictwa o zasoby współdzielone..........................................595 Sekcje krytyczne................................................... ................................................... .........601 Stany wątków................................................... ................................................... ....................606 Zablokowanie ................................................... ................................................... .............606 12 Thinking in Java. Edycja polska Współdziałanie wątków ................................................... ................................................... ....607 Wait i notify................................................... ................................................... ................607 Stosowanie potoków do przekazywania danych pomiędzy wątkami...............................611 Bardziej wyszukane sposoby współdziałania................................................... ................612 Wzajemna blokada................................................... ................................................... ............612 Poprawny sposób zatrzymywania................................................... ........................................617 Przerywanie zablokowanego wątku................................................... .....................................618 Grupy wątków................................................... ................................................... ...................619 Podsumowanie ................................................... ................................................... ..................619 Ćwiczenia................................................... ................................................... ..........................621 Rozdział 14. Tworzenie okienek i apletów ...................................................n............. 623 Podstawy tworzenia apletów................................................... ................................................625 Ograniczenia apletów ................................................... ................................................... .625 Zalety apletów ................................................... ................................................... ............626 Szkielet aplikacji................................................... ................................................... .........627 Uruchamianie apletów w przeglądarce internetowej................................................... .....628 Wykorzystanie programu Appletviewer................................................... ........................629 Testowanie apletów ................................................... ................................................... ....630 Uruchamianie apletów z wiersza poleceń................................................... ............................631 Platforma prezentacyjna ................................................... ................................................632 Tworzenie przycisku ................................................... ................................................... .........634 Przechwytywanie zdarzenia................................................... .................................................635 Pola tekstowe ................................................... ................................................... ....................637 Rozmieszczenie komponentów................................................... ............................................639 BorderLayout................................................... ................................................... ..............639 FlowLayout................................................... ................................................... .................640 GridLayout................................................... ................................................... ..................641 GridBagLayout ................................................... ................................................... ...........642 Bezpośrednie pozycjonowanie ................................................... ......................................642 BoxLayout ................................................... ................................................... ..................642 Najlepsze rozwiązanie? ................................................... .................................................645 Model zdarzeń w Swingu................................................... ................................................... ..646 Rodzaje zdarzeń i odbiorców................................................... .........................................646 Śledzenie wielu zdarzeń ................................................... ................................................652 Katalog komponentów Swing................................................... ..............................................654 Przyciski ................................................... ................................................... .....................655 Ikony ................................................... ................................................... ...........................657 Podpowiedzi ................................................... ................................................... ...............659 Pola tekstowe ................................................... ................................................... ..............659 Ramki................................................... ................................................... ..........................661 Panele z paskami przewijania................................................... ........................................662 Miniedytor ................................................... ................................................... ..................663 Pola wyboru ................................................... ................................................... ................664 Przyciski wyboru ................................................... ................................................... ........666 Listy rozwijane ................................................... ................................................... ...........667 Listy ................................................... ................................................... ............................668 Zakładki ................................................... ................................................... ......................670 Okna komunikatów................................................... ................................................... .....671 Menu ................................................... ................................................... ...........................672 Menu kontekstowe................................................... ................................................... ......677 Rysowanie................................................... ................................................... ...................679 Okna dialogowe ................................................... ................................................... ..........681 Okna dialogowe plików................................................... .................................................685 HTML w komponentach Swing ................................................... ....................................686 Spis treści 13 Suwaki i paski postępu ................................................... ..................................................687 Drzewa................................................... ................................................... ........................688 Tabele ................................................... ................................................... .........................690 Zmiana wyglądu aplikacji................................................... ..............................................692 Schowek................................................... ................................................... ......................694 Pakowanie apletu do pliku JAR ................................................... ...........................................696 Cyfrowe podpisywanie apletów................................................... ...........................................697 JNLP oraz Java Web Start ................................................... ................................................... 701 Techniki programowania ................................................... ................................................... ..706 Dynamiczne dołączanie zdarzeń................................................... ....................................706 Oddzielenie logiki biznesowej od interfejsu użytkownika...............................................708 Postać kanoniczna................................................... ................................................... .......710 Współbieżność i Swing................................................... ................................................... .....710 Interfejs Runnable raz jeszcze ................................................... .......................................711 Zarządzanie współbieżnością ................................................... ........................................713 Programowanie wizualne i Beany................................................... ........................................716 Czym jest Bean ................................................... ................................................... ...........717 Wydobycie informacji o Beanie poprzez introspektor ................................................... ..719 Bardziej wyszukany Bean................................................... ..............................................724 Beany i synchronizacja ................................................... ..................................................727 Pakowanie Beana................................................... ................................................... ........730 Bardziej złożona obsługa Beanów................................................... .................................732 Więcej o Beanach ................................................... ................................................... .......732 Podsumowanie ................................................... ................................................... ..................733 Ćwiczenia................................................... ................................................... ..........................734 Rozdział 15. Wykrywanie problemów ...................................................n.................... 737 Testowanie modułów ................................................... ................................................... ........739 Prosty szkielet testowy ................................................... ..................................................741 JUnit................................................... ................................................... ............................750 Poprawianie niezawodności poprzez wykorzystanie asercji ..................................................754 Składnia asercji................................................... ................................................... ...........755 Użycie asercji do projektowania przez kontrakt................................................... ............758 Przykład: projektowanie przez kontrakt i testowanie modułów metodą „białej skrzynki”..... 761 Konstruowanie przy użyciu narzędzia Ant ................................................... ..........................765 Zautomatyzujmy wszystko ................................................... ............................................766 Problemy z make ................................................... ................................................... ........766 Ant: faktyczny standard................................................... .................................................767 Kontrola wersji przy użyciu CVS................................................... ..................................771 Prace codzienne ................................................... ................................................... ..........774 Rejestracja................................................... ................................................... .........................775 Poziomy rejestracji ................................................... ................................................... .....776 LogRecord ................................................... ................................................... ..................779 Handler ................................................... ................................................... .......................780 Filtry ................................................... ................................................... ...........................784 Formatter................................................... ................................................... .....................785 Przykład: rejestracja informacji poprzez wysyłanie wiadomości pocztą elektroniczną...787 Kontrola poziomu rejestracji przez wykorzystanie przestrzeni nazw ..............................789 Praktyki rejestracyjne stosowane w dużych projektach ................................................... 791 Podsumowanie................................................... ................................................... ............793 Testowanie ................................................... ................................................... ........................794 Testowanie przy wykorzystaniu JDB ................................................... ............................794 Graficzne programy uruchomieniowe ................................................... ...........................799 14 Thinking in Java. Edycja polska Profilowanie i optymalizacja ................................................... ...............................................799 Śledzenie zużycia pamięci................................................... .............................................800 Śledzenie wykorzystania procesora................................................... ...............................800 Testowanie obłożenia ................................................... ................................................... .800 Interfejs profilujący JVM ................................................... ..............................................801 Wykorzystanie HPROF ................................................... .................................................801 Efektywność działania wątków ................................................... .....................................803 Wytyczne optymalizacji ................................................... ................................................804 Doclety ................................................... ................................................... ..............................804 Podsumowanie ................................................... ................................................... ..................806 Ćwiczenia................................................... ................................................... ..........................808 Rozdział 16. Analiza i projekt ...................................................n............................... 811 Metodologia ................................................... ................................................... ......................811 Faza 0.: stwórz plan ................................................... ................................................... ..........813 Określenie celu ................................................... ................................................... ...........814 Faza 1.: co robimy................................................... ................................................... .............814 Faza 2.: jak to stworzymy ................................................... ................................................... .817 Pięć etapów projektowania obiektów ................................................... ............................819 Wytyczne dotyczące tworzenia obiektów ............
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Thinking in Java. Wydanie 3. Edycja polska
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ą: