Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00338 007474 11260080 na godz. na dobę w sumie
Thinking in Java. Edycja polska - książka
Thinking in Java. Edycja polska - książka
Autor: Liczba stron: 816
Wydawca: Helion Język publikacji: polski
ISBN: 83-7197-452-3 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook, audiobook).
'Najlepsza książka na temat Javy', 'Jeden ze zdecydowanie najlepszych kursów Javy, jaki kiedykolwiek widziałem, dla jakiegokolwiek języka' -- to wybrane opinie o propozycji wydawnictwa Helion.

Książka zarówno dla początkujących, jak i ekspertów:

Począwszy od podstaw składni Javy do jej najbardziej zaawansowanych właściwości (obliczenia rozproszone, zaawansowany potencjał obiektowy, wielowątkowość), książka ta została napisana przede wszystkim po to, by rozbudzić w początkującym programiście zainteresowanie Javą. Przystępny styl Bruce'a Eckela i ukierunkowane przykłady powodują, iż nawet najbardziej tajemnicze pojęcia stają się zrozumiałe.

Bruce Eckel jest autorem książki 'Thinking in C++', która zdobyła nagrodę Software Development Jolt Award dla najlepszej książki 1995 roku. Programowaniem zajmuje się profesjonalnie od 20 lat. Uczy ludzi na całym świecie, jak programować z zastosowaniem obiektów już od 1986 roku, najpierw jako konsultant C++ a teraz Javy. Był członkiem Komitetu Standardów C++, napisał 5 innych książek na temat programowania zorientowanego obiektowego, wydał ponad 150 artykułów i prowadził felietony w wielu magazynach informatycznych. Stworzył ścieżkę C++, Javy i Pythona na konferencji Software Development Conference. Zdobył tytuł naukowy z zakresu Zastosowań Fizyki oraz tytuł magistra z zakresu Inżynierii Oprogramowania.

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

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TRE(cid:140)CI SPIS TRE(cid:140)CI KATALOG KSI¥flEK KATALOG KSI¥flEK KATALOG ONLINE KATALOG ONLINE ZAM(cid:211)W DRUKOWANY KATALOG ZAM(cid:211)W DRUKOWANY KATALOG TW(cid:211)J KOSZYK TW(cid:211)J KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAM(cid:211)W INFORMACJE ZAM(cid:211)W INFORMACJE O NOWO(cid:140)CIACH O NOWO(cid:140)CIACH ZAM(cid:211)W CENNIK ZAM(cid:211)W CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥flEK ONLINE FRAGMENTY KSI¥flEK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Thinking in Java edycja polska Autor: Bruce Eckel T‡umaczenie: Adrian Nowak, Szymon Kobalczyk, £ukasz Fryz ISBN: 83-7197-452-3 Tytu‡ orygina‡u: Format: B5, stron: oko‡o 816 Przyk‡ady na ftp: 328 kB Thinking in Java. Second Edition. (cid:132)Najlepsza ksi„¿ka na temat Javy(cid:148), (cid:132)Jeden ze zdecydowanie najlepszych kurs(cid:243)w Javy, jaki kiedykolwiek widzia‡em, dla jakiegokolwiek jŒzyka(cid:148) -- to wybrane opinie o(cid:160) propozycji wydawnictwa Helion. Ksi„¿ka zar(cid:243)wno dla pocz„tkuj„cych, jak i ekspert(cid:243)w: Uczy jŒzyka Java, nie za(cid:156) mechanizm(cid:243)w zale¿nych od platformy systemowej. Poprzez om(cid:243)wienie podstaw wprowadza tematykŒ zaawansowan„. Omawia ponad 300 dzia‡aj„cych program(cid:243)w Javy, ponad 15 000 linii kodu. Dog‡Œbnie obja(cid:156)nienia zasady obiektowo(cid:156)ci oraz ich zastosowania w Javie. Pocz„wszy od podstaw sk‡adni Javy do jej najbardziej zaawansowanych w‡a(cid:156)ciwo(cid:156)ci (obliczenia rozproszone, zaawansowany potencja‡ obiektowy, wielow„tkowo(cid:156)(cid:230)), ksi„¿ka ta zosta‡a napisana przede wszystkim po to, by rozbudzi(cid:230) w pocz„tkuj„cym programi(cid:156)cie zainteresowanie Jav„. PrzystŒpny styl Bruce’a Eckela i ukierunkowane przyk‡ady powoduj„, i¿ nawet najbardziej tajemnicze pojŒcia staj„ siŒ zrozumia‡e. Bruce Eckel jest autorem ksi„¿ki (cid:132) , kt(cid:243)ra zdoby‡a nagrodŒ Software Development Jolt Award dla najlepszej ksi„¿ki 1995 roku. Programowaniem zajmuje siŒ profesjonalnie od 20 lat. Uczy ludzi na ca‡ym (cid:156)wiecie, jak programowa(cid:230) z(cid:160) zastosowaniem obiekt(cid:243)w ju¿ od 1986 roku, najpierw jako konsultant C++ a teraz Javy. By‡ cz‡onkiem Komitetu Standard(cid:243)w C++, napisa‡ 5 innych ksi„¿ek na temat programowania zorientowanego obiektowego, wyda‡ ponad 150 artyku‡(cid:243)w i prowadzi‡ felietony w wielu magazynach informatycznych. Stworzy‡ (cid:156)cie¿kŒ C++, Javy i Pythona na konferencji Software Development Conference. Zdoby‡ tytu‡ naukowy z zakresu Zastosowaæ Fizyki oraz tytu‡ magistra z zakresu In¿ynierii Oprogramowania. Thinking in C++(cid:148) Nagroda dla najlepszej ksi„¿ki przyznana przez czytelnik(cid:243)w JavaWorld w 2000 roku. Nagroda dla najlepszej ksi„¿ki przyznana przez redakcjŒ Java Developer Journal, 1999. Nagroda za tw(cid:243)rczo(cid:156)(cid:230) od Software Development Magazine, 1999. #4786/- .8o9+-    .36/836+/6836-2/13   6/.3;+    Przedmowa do wydania drugiego ................................................... .........................................23 Java 2................................................... ................................................... .........................24 463;+./2/   Warunki wstępne................................................... ................................................... ................25 Nauka Javy................................................... ................................................... .........................26 Cele ................................................... ................................................... ....................................26 Dokumentacja on-line................................................... ................................................... ........27 Zawartość rozdziałów................................................... ................................................... ........27 Ćwiczenia................................................... ................................................... ...........................32 Kody źródłowe................................................... ................................................... ...................32 Konwencje zapisu................................................... ................................................... ......33 Wersje Javy................................................... ................................................... ........................34 Seminaria ................................................... ................................................... ...........................34 Projekt okładki ................................................... ................................................... ...................35 Podziękowania ................................................... ................................................... ...................35 Współpracownicy internetowi................................................... ......................................37 3.+o  463;+./2/;;+83,/8(cid:31);  Postępująca abstrakcja ................................................... ................................................... .......40 Obiekt posiada interfejs ................................................... ................................................... .....41 Ukrywanie implementacji................................................... ................................................... ..43 Wielokrotne wykorzystanie implementacji ................................................... ..........................44 Dziedziczenie: wielokrotne użycie interfejsu ................................................... .......................45 Relacja „bycia czymś” a relacja „bycia podobnym do czegoś” ......................................48 Wymienialność obiektów z użyciem polimorfizmu................................................... ..............49 Abstrakcyjne klasy bazowe i interfejsy ................................................... ........................52  $2212+:+ Obiekty, sposób przechowywania i czas życia ................................................... .....................53 Kolekcje i iteratory ................................................... ................................................... ....54 Hierarchia z pojedynczym korzeniem ................................................... ..........................55 Biblioteki kolekcji i ich stosowanie................................................... ..............................56 Dylemat domowy: kto powinien posprzątać?................................................... ...............57 Obsługa wyjątków — eliminowanie błędów................................................... ........................58 Wielowątkowość................................................... ................................................... ................59 Trwałość................................................... ................................................... .............................60 Java i Internet ................................................... ................................................... .....................60 Czym jest Internet?................................................... ................................................... ....60 Programowanie po stronie klienta ................................................... ................................62 Programowanie po stronie serwera ................................................... ..............................67 Osobny obszar: aplikacje................................................... ..............................................67 Analiza i projektowanie ................................................... ................................................... .....68 Etap 0. Zrób plan ................................................... ................................................... .......70 Etap 1. Co mamy stworzyć? ................................................... .........................................70 Etap 2. Jak to zrobimy? ................................................... ................................................73 Etap 3. Zbuduj jądro................................................... ................................................... ..76 Etap 4. Przeglądaj przypadki użycia................................................... .............................76 Etap 5. Ewolucja................................................... ................................................... ........77 Planowanie popłaca................................................... ................................................... ...78 Programowanie ekstremalne (Extreme Programming)................................................... .........79 Najpierw napisz testy................................................... ................................................... .79 Programowanie w parach ................................................... .............................................80 Dlaczego Java odnosi sukcesy ................................................... ..............................................81 Systemy jest łatwiej opisać i zrozumieć ................................................... .......................81 Maksymalne zwiększenie wydajności dzięki bibliotekom..............................................81 Obsługa błędów................................................... ................................................... .........82 Programowanie na wielką skalę ................................................... ...................................82 Strategie przejścia................................................... ................................................... ..............82 Wskazówki ................................................... ................................................... ................82 Problemy zarządzania................................................... ................................................... 84 Java kontra C++ ................................................... ................................................... .................85 Podsumowanie ................................................... ................................................... ...................86 3.+o  7783/783,/8/   Dostęp do obiektów poprzez referencje................................................... ................................89 Wszystkie obiekty trzeba stworzyć................................................... .......................................90 Gdzie przechowujemy dane?................................................... ........................................91 Przypadek specjalny: typy podstawowe................................................... .......................92 Tablice w Javie................................................... ................................................... ..........93 #4786/-  Nigdy nie ma potrzeby niszczenia obiektu ................................................... ...........................94 Zasięg................................................... ................................................... .........................94 Zasięg obiektów................................................... ................................................... .........94 Tworzenie nowych typów danych — klasa................................................... ..........................95 Pola i metody ................................................... ................................................... .............96 Metody, argumenty i wartości zwracane ................................................... ..............................97 Lista argumentów ................................................... ................................................... ......98 Tworzenie programu w Javie................................................... ................................................99 Widoczność nazw................................................... ................................................... ......99 Wykorzystanie innych komponentów ................................................... ........................100 Słowo kluczowe static ................................................... ................................................101 Twój pierwszy program w Javie................................................... .........................................102 Kompilacja i uruchomienie................................................... .........................................103 Komentarze oraz dokumentowanie kodu................................................... ............................104 Dokumentacja w komentarzach................................................... ..................................105 Składnia ................................................... ................................................... ...................105 Osadzony HTML ................................................... ................................................... .....106 @see: odwołanie do innych klas ................................................... ................................106 Znaczniki dokumentowania klas ................................................... ................................107 Znaczniki dokumentacji zmiennych................................................... ...........................107 Znaczniki dokumentacji metod................................................ ......................................107 Przykład dokumentowania kodu................................................... .................................108 Styl programowania ................................................... ................................................... .........109 Podsumowanie ................................................... ................................................... .................110 Ćwiczenia................................................... ................................................... .........................110 3.+o #8/63;+2/3/23-;32+2+ Używanie operatorów Javy................................................... .................................................111 Kolejność................................................... ................................................... .................111 Przypisanie................................................... ................................................... ...............112 Operatory matematyczne................................................... ............................................114 Operatory zwiększania i zmniejszania................................................... ........................116 Operatory relacji................................................... ................................................... ......117 Operatory logiczne................................................... ................................................... ...118 Operatory bitowe ................................................... ................................................... .....120 Operatory przesunięcia................................................... ...............................................121 Operator trójargumentowy if-else ................................................... ..............................124 Przecinek................................................... ................................................... ..................125 Łańcuchowy operator + ................................................... ..............................................125 Najczęstsze pułapki przy używaniu operatorów ................................................... ........126 Operatory rzutowania ................................................... .................................................126 W Javie nie ma „sizeof”................................................... ..............................................129  $2212+:+ Powtórka z kolejności operatorów ................................................... .............................129 Kompendium operatorów................................................... ...........................................130 Sterowanie wykonaniem ................................................... ................................................... ..138 Prawda i fałsz................................................... ................................................... ...........138 if-else................................................... ................................................... .......................138 return................................................... ................................................... ........................139 Iteracja ................................................... ................................................... .....................139 do-while................................................... ................................................... ...................140 for................................................ ................................................... ................................140 break i continue................................................... ................................................... ........142 switch................................................... ................................................... .......................146 Podsumowanie ................................................... ................................................... .................150 Ćwiczenia................................................... ................................................... .........................150 3.+o 2-++-+7468+2/   Gwarantowana inicjalizacja przez konstruktor................................................... ...................151 Przeciążanie metod................................................ ................................................... ..............153 Rozróżnianie przeciążonych metod................................................... ............................155 Przeciążanie a typy podstawowe................................................... ................................155 Przeciążanie przez wartości zwracane................................................... ........................158 Konstruktory domyślne ................................................... ..............................................159 Słowo kluczowe this................................................... ................................................... 159 Sprzątanie: finalizacja i odśmiecanie pamięci ................................................... ....................162 Do czego służy finalize()?................................................... ..........................................163 Musimy przeprowadzić sprzątanie ................................................... .............................164 Warunek śmierci................................................... ................................................... ......167 Jak działa odśmiecacz pamięci................................................... ...................................168 Inicjalizacja składowych ................................................... ................................................... ..171 Określanie sposobu inicjalizacji................................................... .................................172 Inicjalizacja w konstruktorze................................................... ......................................173 Inicjalizacja tablic................................................... ................................................... ............178 Tablice wielowymiarowe ................................................... ...........................................182 Podsumowanie ................................................... ................................................... .................185 Ćwiczenia................................................... ................................................... .........................185 3.+o  6;+2/4//28+-   Pakiet — jednostka biblioteczna................................................... .........................................188 Tworzenie unikatowych nazw pakietów ................................................... ....................189 Własna biblioteka narzędziowa................................................... ..................................192 Wykorzystanie instrukcji import do zmiany zachowania..............................................193 Pułapka związana z pakietami................................................... ....................................195 #4786/-  Modyfikatory dostępu w Javie................................................... ............................................195 Dostęp „przyjazny”................................................... ................................................... ..195 public: dostęp do interfejsu................................................... .........................................196 private: nie dotykać! ................................................... ................................................... 198 protected: „pewien rodzaj przyjacielskości” ................................................... ..............199 Interfejs i implementacja................................................... ................................................... ..200 Dostęp do klas................................................... ................................................... ..................201 Podsumowanie ................................................... ................................................... .................204 Ćwiczenia................................................... ................................................... .........................205 3.+o  /36382/;3678+2/+7   Składnia kompozycji................................................... ................................................... ........207 Składnia dziedziczenia................................................... ................................................... .....210 Inicjalizacja klasy bazowej................................................... .........................................212 Łączenie kompozycji i dziedziczenia ................................................... .................................214 Zapewnienie poprawnego sprzątania................................................... ..........................215 Ukrywanie nazw................................................... ................................................... ......218 Wybór między kompozycją a dziedziczeniem................................................... ....................219 protected................................................... ................................................... ...........................220 Przyrostowe tworzenie oprogramowania................................................... ............................221 Rzutowanie w górę................................................... ................................................... ...........221 Dlaczego „w górę”?................................................... ................................................... .222 Słowo kluczowe final................................................... ................................................... .......223 Zmienne ostateczne................................................... ................................................... ..223 Metody ostateczne ................................................... ................................................... ...227 Klasy ostateczne ................................................... ................................................... ......228 Ostrożnie z ostatecznością................................................... ..........................................229 Inicjalizacja i ładowanie klas................................................... ..............................................230 Inicjalizacja w przypadku dziedziczenia ................................................... ....................230 Podsumowanie ................................................... ................................................... .................232 Ćwiczenia................................................... ................................................... .........................232 3.+o  3360   Rzutowanie w górę raz jeszcze ................................................... ...........................................235 Zapominanie o typie obiektu ................................................... ......................................236 Mały trik................................................... ................................................... ...........................238 Wiązanie wywołania metody................................................... ......................................238 Uzyskiwanie poprawnego działania ................................................... ...........................239 Rozszerzalność ................................................... ................................................... ........241 $2212+:+ Przesłanianie kontra przeciążanie ................................................... .......................................244 Klasy i metody abstrakcyjne ................................................... ...............................................245 Konstruktory a polimorfizm................................................... ................................................248 Kolejność wywołań konstruktorów................................................... ............................248 Dziedziczenie a metoda finalize() ................................................... ..............................250 Zachowanie się metod polimorficznych wewnątrz konstruktorów...............................253 Projektowanie z użyciem dziedziczenia ................................................... .............................255 Czyste dziedziczenie kontra rozszerzanie ................................................... ..................256 Rzutowanie w dół a identyfikacja typu w czasie wykonania ........................................257 Podsumowanie ................................................... ................................................... .................259 Ćwiczenia................................................... ................................................... .........................259 3.+o 28/60/7+7;/;2+862/   Interfejsy ................................................... ................................................... ..........................261 „Wielokrotne dziedziczenie” w Javie................................................... .........................264 Rozszerzanie interfejsu poprzez dziedziczenie ................................................... ..........267 Grupowanie stałych ................................................... ................................................... .268 Inicjalizacja pól interfejsów ................................................... .......................................269 Zagnieżdżanie interfejsów................................................... ..........................................270 Klasy wewnętrzne ................................................... ................................................... ............272 Klasy wewnętrzne a rzutowanie w górę................................................... .....................274 Klasy wewnętrzne w metodach i zakresach ................................................... ...............276 Anonimowe klasy wewnętrzne................................................... ...................................278 Połączenie z klasą zewnętrzną................................................... ....................................280 Statyczne klasy wewnętrzne................................................... .......................................282 Odwoływanie się do obiektu klasy zewnętrznej................................................... .........284 Sięganie na zewnątrz z klasy wielokrotnie zagnieżdżonej............................................285 Dziedziczenie po klasach wewnętrznych ................................................... ...................285 Czy klasy wewnętrzne mogą być przesłaniane?................................................... .........286 Identyfikatory klas wewnętrznych................................................... ..............................288 Dlaczego klasy wewnętrzne?................................................... ......................................288 Klasy wewnętrzne a szkielety sterowania ................................................... ..................293 Podsumowanie ................................................... ................................................... .................299 Ćwiczenia................................................... ................................................... .........................299 3.+o  6/-3;;+2/3,/8(cid:31);    Tablice ................................................... ................................................... .............................303 Tablice to obiekty ................................................... ................................................... ....304 Tablice jako wartości zwracane................................................... ..................................307 Klasa Arrays ................................................... ................................................... ............308 Wypełnianie tablicy................................................... ................................................... .317 Kopiowanie tablic................................................... ................................................... ....318 #4786/- Porównywanie tablic ................................................... ..................................................319 Porównywanie elementów tablic................................................... ................................320 Sortowanie tablic................................................... ................................................... .....323 Przeszukiwanie tablicy posortowanej................................................... .........................324 Podsumowanie wiadomości o tablicach................................................... .....................325 Wprowadzenie do kontenerów................................................. ..............................................326 Wypisanie zawartości kontenerów ................................................... .............................327 Wypełnianie kontenerów................................................... ............................................328 Wada kontenera: nieznany typ................................................... ............................................333 Czasami mimo wszystko działa................................................... ..................................335 Tworzenie świadomej typu klasy ArrayList................................................... ...............336 Iteratory................................................... ................................................... ............................337 Rodzaje kontenerów................................................. ................................................... ...........340 Interfejs Collection................................................... ................................................... ...........343 Interfejs List ................................................... ................................................... .....................345 Stos na podstawie LinkedList................................................... .....................................348 Kolejka na podstawie LinkedList ................................................... ...............................349 Interfejs Set ................................................... ................................................... ......................350 SortedSet................................................... ................................................... ..................352 Interfejs Map ................................................... ................................................... ....................352 SortedMap........................................... ................................................... ........................356 Haszowanie i kody haszujące................................................... .....................................356 Przesłonięcie metody hashCode() ................................................... ..............................363 Przechowywanie referencji................................................... .................................................365 WeakHashMap ................................................... ................................................... ........367 Iteratory ponownie ................................................... ................................................... ...........369 Wybór implementacji................................................... ................................................... .......370 Wybór między listami................................................... .................................................370 Wybór implementacji zbioru ................................................... ......................................373 Wybór implementacji odwzorowania................................................... .........................375 Sortowanie i przeszukiwanie list ................................................... ........................................377 Dodatkowe usługi ................................................... ................................................... ............377 Niemodyfikowalne kontenery Collection i Map ................................................... ........378 Synchronizacja Collection i Map.................................................. .................................379 Nie obsługiwane operacje................................................... ................................................... 380 Kontenery Java 1.0 i 1.1................................................ ................................................... ......382 Vector i Enumeration................................................... ..................................................383 Hashtable ................................................... ................................................... .................384 Stack............................................... ................................................... .............................384 BitSet ................................................... ................................................... .......................385 Podsumowanie ................................................... ................................................... .................386 Ćwiczenia................................................... ................................................... .........................387  $2212+:+ 3.+o ,7o91+,o+.(cid:31);+433-;8(cid:31);  Podstawy obsługi wyjątków................................................. ..................................................392 Parametry wyjątków................................................... ................................................... 393 Przechwytywanie wyjątku ................................................... ..................................................393 Blok try ................................................... ................................................... ....................394 Obsługa wyjątków ................................................... ................................................... ...394 Tworzenie własnych wyjątków................................................... ...........................................395 Specyfikacja wyjątków ................................................... ................................................... ....398 Przechwytywanie dowolnego wyjątku ................................................... .......................399 Ponowne wyrzucanie wyjątków ................................................... .................................401 Standardowe wyjątki Javy................................................... ................................................... 404 Specjalny przypadek RuntimeException................................................... ....................404 Robienie porządków w finally ................................................... ............................................406 Do czego służy finally? ................................................... ..............................................407 Pułapka: zagubiony wyjątek................................................... .......................................409 Ograniczenia wyjątków................................................. ................................................... ......410 Konstruktory ................................................... ................................................... ....................413 Dopasowywanie wyjątków ................................................... .................................................416 Wskazówki ................................................... ................................................... ..............417 Podsumowanie ................................................... ................................................... .................418 Ćwiczenia................................................... ................................................... .........................418 3.+o #78/;/-+.;-+;+:/  Klasa File................................................... ................................................... .........................421 Wypisywanie zawartości katalogu................................................... ..............................422 Operacje na katalogach................................................... ...............................................425 Wejście i wyjście ................................................... ................................................... .............427 Typy InputStream ................................................... ................................................... ....427 Typy OutputStream................................................... ................................................... ..429 Dodawanie atrybutów i użytecznych interfejsów................................................... ...............430 Czytanie z InputStream za pomocą FilterInputStream..................................................430 Zapis do OutputStream za pomocą FilterOutputStream................................................431 Czytelnicy i pisarze................................................... ................................................... ..........433 Źródła i ujścia danych................................................... .................................................433 Modyfikacja zachowania strumienia................................................... ..........................434 Klasy nie zmienione ................................................... ................................................... 435 Osobna i samodzielna RandomAccessFile................................................... .........................435 Typowe zastosowania strumieni I/O................................................... ...................................436 Strumienie wejścia ................................................... ................................................... ..438 Strumienie wyjścia ................................................... ................................................... ..440 Strumienie typu „pipe” ................................................... ...............................................441 #4786/-  Standardowe wejście-wyjście................................................... .............................................442 Czytanie ze standardowego wejścia................................................... ...........................442 Zamiana System.out na PrintWriter ................................................... ...........................443 Przekierowywanie standardowego wejścia-wyjścia ................................................... ..443 Kompresja................................................... ................................................... ........................444 Prosta kompresja do formatu GZIP ................................................... ............................445 Przechowywanie wielu plików w formacie Zip ................................................... .........446 Archiwa Javy (JAR) ................................................... ................................................... 448 Serializacja obiektów................................................... ................................................... .......450 Odnajdywanie klasy................................................... ................................................... .453 Kontrola serializacji ................................................... ................................................... 454 Stosowanie trwałości................................................... ..................................................462 Atomizacja wejścia................................................... ................................................... ..........468 StreamTokenizer................................................... ................................................... ......468 StringTokenizer ................................................... ................................................... .......470 Sprawdzanie poprawności stylu................................................... ..................................472 Podsumowanie ................................................... ................................................... .................479 Ćwiczenia................................................... ................................................... .........................480 3.+o  ./280+-+849;-+7/;32+2+  Potrzeba mechanizmu RTTI ................................................... ...............................................483 Obiekt Class................................................... ................................................... .............485 Sprawdzanie przed rzutowaniem................................................... ................................488 Składnia RTTI................................................... ................................................... ..................494 Odzwierciedlenia — informacja o klasie w czasie wykonania..............................................496 Ekstraktor metod klasowych................................................... .......................................497 Podsumowanie ................................................... ................................................... .................501 Ćwiczenia................................................... ................................................... .........................502 3.+o  $;36/2/3/2/+4/8(cid:31);    Podstawy tworzenia apletów................................................ ..................................................507 Ograniczenia apletów ................................................... .................................................507 Zalety apletów ................................................... ................................................... .........508 Szkielet aplikacji ................................................... ................................................... .....508 Uruchamianie apletów w przeglądarce internetowej................................................... ..509 Wykorzystanie programu Appletviewer................................................... .....................511 Testowanie apletów................................................... ................................................... .511 Uruchamianie apletów z wiersza poleceń................................................... ...........................512 Platforma prezentacyjna ................................................... .............................................514 Wykorzystanie Windows Explorer................................................... .............................516 Tworzenie przycisku ................................................... ................................................... ........516  $2212+:+ Przechwytywanie zdarzenia................................................... ................................................517 Pola tekstowe ................................................... ................................................... ...................520 Rozmieszczenie komponentów................................................... ...........................................521 BorderLayout................................................... ................................................... ...........521 FlowLayout................................................... ................................................... ..............522 GridLayout................................................... ................................................... ...............523 GridBagLayout ................................................... ................................................... ........524 Bezpośrednie pozycjonowanie ................................................... ...................................524 BoxLayout ................................................... ................................................... ...............524 Najlepsze rozwiązanie? ................................................... ..............................................527 Model zdarzeń w Swingu................................................... ................................................... .528 Rodzaje zdarzeń i odbiorców ................................................... .....................................528 Śledzenie wielu zdarzeń................................................... ..............................................533 Katalog komponentów Swing................................................... .............................................536 Przyciski ................................................... ................................................... ..................536 Ikony................................................... ................................................... ........................539 Podpowiedzi ................................................... ................................................... ............540 Pola tekstowe................................................... ................................................... ...........540 Ramki................................................... ................................................... .......................542 Panele z paskami przewijania................................................... .....................................543 Miniedytor ................................................... ................................................... ...............545 Pola wyboru................................................... ................................................... .............546 Przyciski wyboru ................................................... ................................................... .....547 Listy rozwijane ................................................... ................................................... ........548 Listy ................................................... ................................................... .........................549 Zakładki................................................... ................................................... ...................551 Okienka komunikatów................................................... ................................................552 Menu................................................... ................................................... ........................554 Menu kontekstowe................................................... ................................................... ...559 Rysowanie.......................................... ................................................... .........................560 Okienka dialogowe................................................... ................................................... ..563 Okienka dialogowe plików................................................... .........................................566 HTML w komponentach Swing ................................................... .................................568 Suwaki i paski postępu ................................................... ...............................................569 Drzewa................................................... ................................................... .....................570 Tabele ................................................... ................................................... ......................572 Zmiana wyglądu aplikacji ................................................... ..........................................573 Schowek................................................... ................................................... ...................575 Pakowanie apletu do pliku JAR ................................................... ..........................................578 Techniki programowania ................................................... ................................................... .578 Dynamiczne dołączanie zdarzeń................................................... .................................579 Oddzielenie logiki biznesowej od interfejsu użytkownika............................................580 Postać kanoniczna................................................... ................................................... ....582 #4786/-  Programowanie wizualne i Beany................................................... .......................................583 Czym jest Bean? ................................................... ................................................... ......584 Wydobycie informacji o Beanie poprzez introspektor ..................................................586 Bardziej wyszukany Bean................................................... ...........................................591 Pakowanie Beana................................................... ................................................... .....594 Bardziej złożona obsługa Beanów................................................... ..............................595 Więcej o Beanach ................................................... ................................................... ....596 Podsumowanie ................................................... ................................................... .................596 Ćwiczenia................................................... ................................................... .........................597 3.+o   /3;83;3   Interaktywny interfejs użytkownika................................................... ....................................601 Dziedziczenie z klasy Thread................................................... .....................................603 Wielowątkowość do budowy interaktywnego interfejsu...............................................605 Połączenie wątku z klasą główną................................................... ................................607 Tworzenie wielu wątków................................................. ..............................................609 Wątki demony................................................... ................................................... ..........611 Współdzielenie ograniczonych zasobów ................................................... ............................613 Niewłaściwy dostęp do zasobów................................................... ................................613 Jak Java współdzieli zasoby ................................................... .......................................617 JavaBeans w innym wydaniu................................................... ......................................621 Blokowanie ................................................... ................................................... ......................625 Zablokowanie ................................................... ................................................... ..........625 Impas................................................... ................................................... ........................634 Priorytety................................................... ................................................... ..........................638 Odczyt i ustawienie priorytetów................................................... .................................638 Grupy wątków ................................................... ................................................... .........641 Runnable ................................................... ................................................... ..........................647 Zbyt wiele wątków ................................................... ................................................... ..650 Podsumowanie ................................................... ................................................... .................652 Ćwiczenia................................................... ................................................... .........................654 3.+o   6/8;+6+2/63463732/   Programowanie sieciowe................................................... ................................................... .658 Identyfikowanie maszyny................................................... ...........................................658 Gniazda................................................... ................................................... ....................661 Obsługa wielu klientów................................................... ..............................................666 Datagramy................................................... ................................................... ................671 Użycie adresów URL w apletach................................................... ................................671 Więcej o sieciach................................................... ................................................... .....673  $2212+:+ Java DataBase Connectivity (JDBC) ................................................... ..................................673 Uruchamianie przykładu................................................... .............................................676 Wersja programu wyszukującego z interfejsem graficznym.........................................679 Dlaczego interfejs JDBC wydaje się tak skomplikowany.............................................681 Bardziej wyrafinowany przykład.................................................. .................................682 Serwlety ................................................... ................................................... ...........................688 Podstawowy serwlet ................................................... ................................................... 689 Serwlety a wielowątkowość ................................................... .......................................692 Obsługiwanie sesji w serwletach................................................... ................................693 Uruchamianie przykładowych serwletów ................................................... ..................697 Java Server Pages.................................. ................................................... ..............................697 Obiekty niejawne................................................... ................................................... .....698 Dyrektywy JSP ................................................... ................................................... ........699 Elementy skryptowe JSP ................................................... ............................................700 Wydobywanie pól i ich wartości................................................... ................................702 Atrybuty strony JSP oraz zasięg ich ważności ................................................... ...........703 Manipulowanie sesjami z poziomu stron JSP................................................... .............704 Tworzenie i modyfikowanie cookies................................................... ..........................705 Podsumowanie tematu JSP................................................... .........................................706 RMI (Remote Method Invocation)................................................... ......................................707 Odległe interfejsy................................................... ................................................... .....707 Implementacja odległego interfejsu................................................... ............................708 Tworzenie namiastki i szkieletu ................................................... .................................710 Użycie odległego obiektu ................................................... ...........................................711 CORBA................................................... ................................................... ............................712 Podstawy CORBA................................................... ................................................... ...712 Przykład................................................... ................................................... ...................714 Aplety Javy i CORBA ................................................... ................................................718 CORBA a RMI ................................................... ................................................... ........718 Enterprise JavaBeans ................................................... ................................................... .......719 JavaBeans a EJB................................................... ................................................... ......720 Specyfikacja EJB................................................... ................................................... .....720 Komponenty EJB................................................... ................................................... .....720 Części komponentu EJB................................................... .............................................722 Działanie EJB ................................................... ................................................... ..........723 Rodzaje EJB................................................... ................................................... .............723 Tworzenie EJB................................................... ................................................... .........724 Podsumowanie EJB ................................................... ................................................... .728 Jini — serwisy rozproszone ................................................... ................................................728 Zadania Jini................................................... ................................................... ..............728 Co to jest Jini? ................................................... ................................................... .........729 Jak to działa ................................................... ................................................... .............730 Proces odkrywania................................................... ................................................... ...730 #4786/-  Proces dołączenia ................................................... ................................................... ....730 Proces lokalizacji................................................... ................................................... .....731 Rozdzielenie interfejsu od implementacji ................................................... ..................732 Abstrakcja systemów rozproszonych................................................... ..........................732 Podsumowanie ................................................... ................................................... .................733 Ćwiczenia................................................... ................................................... .........................733 3.+8/ 6/+;+2/;6+-+2/3,/8(cid:31);  Przekazywanie referencji................................................... ................................................... .735 Odnośniki................................................... ................................................... .................736 Tworzenie kopii lokalnych................................................... ..................................................738 Przekazywanie przez wartość................................................... .....................................738 Klonowanie obiektów................................................... .................................................739 Dodanie klonowalności do klasy................................................... ................................740 Udane klonowanie ................................................... ................................................... ...741 Działanie Object.clone()................................................... .............................................743 Klonowanie złożonego obiektu ................................................... ..................................745 Głęboka kopia ArrayList ................................................... ............................................747 Głęboka kopia poprzez serializację................................................... ............................748 Dodanie klonowalności w dół hierarchii................................................... ......
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

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