java. programowanie obiektowe full scan, ebooki7
[ Pobierz całość w formacie PDF ]
IDZ DO
PRZYK£ADOW
Java. Programowanie
SPIS TREŒCI
obiektowe
KATALOG KSI¥¯EK
Autor: Marek Wierzbicki
ISBN: 83-246-0290-9
Format: B5, stron: 264
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
Doskona³e wprowadzenie w œwiat obiektowoœci
• Podstawowe zasady programowania obiektowego
Programowanie sterowane zdarzeniami
Obs³uga wyj¹tków i wielow¹tkowoœci
Programowanie obiektowe to technologia, która zdoby³a ju¿ bardzo mocn¹ pozycjê
wœród twórców oprogramowania. Nadal jednak wielu programistów, którzy zdobywali
doœwiadczenie, u¿ywaj¹c jêzyków proceduralnych, ma problemy z jej zrozumieniem
i wszechstronnym stosowaniem. Wiele jêzyków programowania okreœlanych mianem
„obiektowe” wywodzi siê z jêzyków proceduralnych, co ogranicza mo¿liwoœci
wykorzystywania wszystkich zalet obiektowoœci. Ograniczeñ tych pozbawiona jest
Java — stworzony od podstaw, nowoczesny, bezpieczny, niezale¿ny od typu komputera
i systemu operacyjnego, w pe³ni obiektowy jêzyk programowania.
Ksi¹¿ka „Java. Programowanie obiektowe” opisuje wszystkie aspekty programowania
obiektowego w Javie. Pocz¹tkuj¹cy u¿ytkownicy tego jêzyka znajd¹ w niej wyjaœnienia
nawet najbardziej skomplikowanych mechanizmów obiektowoœci, a ci, którzy posiadaj¹
ju¿ pewne doœwiadczenie, mog¹ wykorzystaæ j¹ w charakterze podrêcznego
kompendium wiedzy. Mo¿na znaleŸæ w niej omówienie zarówno podstawowych
zagadnieñ, jak i zaawansowanych technik obs³ugi b³êdów, programowania
wielow¹tkowego i sterowanego zdarzeniami. W ksi¹¿ce przedstawiono równie¿ metody
tworzenia wydajnie dzia³aj¹cych programów, które do uruchomienia nie wymagaj¹
maszyn o potê¿nej mocy obliczeniowej.
Cechy programowania obiektowego
ObiektowoϾ w Javie
Tworzenie i stosowanie klas i obiektów
Budowanie pakietów
Tworzenie apletów
Komunikacja apletów ze skryptami Java Script
Obiekty nas³uchuj¹ce i obs³uga zdarzeñ
Przechwytywanie wyj¹tków
Synchronizacja w¹tków
Poznaj mo¿liwoœci technologii obiektowej w praktyce
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
ONOWOŒCIACH
ZAMÓW CENNIK
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
Od autora ......................................................................................... 7
Rozdział 1. Wprowadzenie ................................................................................ 11
1.1. Ogólne cechy programowania obiektowego ...........................................................12
1.1.1. Hermetyzacja ................................................................................................13
1.1.2. Dziedziczenie cech ........................................................................................14
1.1.3. Dziedziczenie metod i polimorfizm ..............................................................16
1.1.4. Nowa jakość działania ..................................................................................17
1.2. Cechy szczególne obiektowości Javy ......................................................................18
1.2.1. Obiekty w Javie .............................................................................................21
1.2.2. Deklaracje dostępności .................................................................................22
1.2.3. Klasy wewnętrzne i zewnętrzne ....................................................................22
1.2.4. Klasy abstrakcyjne ........................................................................................23
1.2.5. Interfejsy .......................................................................................................24
1.2.6. Implementacje ...............................................................................................25
1.2.7. Klasy finalne .................................................................................................25
1.2.8. Metody i klasy statyczne ...............................................................................26
1.2.9. Klasy anonimowe ..........................................................................................27
1.2.10. Obiekty refleksyjne .......................................................................................28
1.2.11. Zdalne wykonywanie metod .........................................................................28
1.2.12. Pakiety ..........................................................................................................29
1.2.13. Zarządzanie pamięcią ...................................................................................30
1.2.14. Konwersja typów ..........................................................................................30
1.3. Podsumowanie .........................................................................................................31
Rozdział 2. Klasy i obiekty w Javie .................................................................... 33
2.1. Klasy ........................................................................................................................33
2.1.1. Tworzenie klas ..............................................................................................33
2.1.2. Pola ................................................................................................................35
2.1.3. Metody ..........................................................................................................35
2.1.4. Hermetyzacja i modyfikator private .............................................................36
2.1.5. Przeciążanie metod .......................................................................................37
2.1.6. Słowo kluczowe this .....................................................................................38
2.1.7. Konstruktor ...................................................................................................39
2.1.8. Przeciążanie konstruktorów ..........................................................................40
2.1.9. Dziedziczenie ................................................................................................43
2.1.10. Inicjator klasy i obiektu ................................................................................44
2.1.11. Kolejność inicjacji klas .................................................................................47
2.1.12. Destruktor .....................................................................................................50
4
Java. Programowanie obiektowe
2.1.13. Przykrywanie metod .....................................................................................51
2.1.14. Odwołanie do klas nadrzędnych ...................................................................52
2.1.15. Odwołanie do pól klas nadrzędnych .............................................................53
2.1.16. Klasy abstrakcyjne ........................................................................................54
2.2. Obiekty ....................................................................................................................55
2.2.1. Rozważania o adresie ....................................................................................55
2.2.2. Jawne użycie obiektów .................................................................................56
2.2.3. Kopiowanie obiektów ...................................................................................58
2.2.4. Niejawne używanie obiektów .......................................................................59
2.2.5. Typ zmiennej i obiektu. Operator instanceof ................................................60
2.2.6. Efekty polimorfizmu .....................................................................................62
2.3. Klasy wewnętrzne i lokalne ....................................................................................63
2.3.1. Dostęp do zmiennych klasy zawierającej .....................................................65
2.3.2. Polimorfizm i zmienne klasy zawierającej ...................................................66
2.3.3. Zmienne lokalne w klasie lokalnej ................................................................68
2.3.4. this w klasach wewnętrznych ........................................................................69
2.3.5. Korzystanie z klas wewnętrznych .................................................................71
2.4. Interfejsy ..................................................................................................................73
2.4.1. Definicja interfejsu ........................................................................................74
2.4.2. Implementacje ...............................................................................................74
2.4.3. Zastosowanie interfejsów ..............................................................................76
2.4.4. Stałe symboliczne .........................................................................................77
2.4.5. Trochę kodu w interfejsie .............................................................................79
2.4.6. Dziedziczenie interfejsów .............................................................................81
2.4.7. Egzemplarz interfejsu ...................................................................................83
2.5. Klasy anonimowe ....................................................................................................84
2.5.1. Klasyczne użycie klasy anonimowej ............................................................85
2.5.2. Jawna klasa anonimowa ................................................................................87
2.5.3. Konstruktor klasy anonimowej .....................................................................88
2.6. Obiekty refleksyjne .................................................................................................89
2.6.1. Obiekt tworzony refleksyjnie ........................................................................89
2.6.2. Ogólne rozpoznawanie klasy ........................................................................91
2.6.3. Przykład użycia refleksji ...............................................................................92
2.6.4. Związek refleksji z obiektowością ................................................................94
2.7. Metody .....................................................................................................................95
2.7.1. Zwracanie wartości przez metodę .................................................................95
2.7.2. Przekazywanie parametrów przez wartość ...................................................96
2.7.3. Zmiana wartości parametru ...........................................................................97
2.7.4. Metody ze zmienną liczbą parametrów ........................................................99
2.7.5. Zakres nazw zmiennych ..............................................................................100
2.8. Pakiety ...................................................................................................................101
2.8.1. Tworzenie pakietów ....................................................................................101
2.8.2. Używanie pakietów .....................................................................................103
2.8.3. Lista pakietów .............................................................................................104
2.9. Modyfikatory .........................................................................................................105
2.9.1. Modyfikatory dostępu .................................................................................106
2.9.2. Pokrywanie modyfikatorów dostępu ..........................................................107
2.9.3. Metody i pola statyczne ..............................................................................109
2.9.4. Pola finalne .................................................................................................111
2.9.5. Metody i klasy finalne .................................................................................112
2.9.6. Pola podlegające zmianie ............................................................................113
2.9.7. Metody synchronizowane ...........................................................................113
2.9.8. Pola ulotne ...................................................................................................114
2.9.9. Metody rodzime ..........................................................................................114
2.10. Podsumowanie ......................................................................................................115
Spis treści
5
Rozdział 3. Aplet jako obiekt na stronie HTML ................................................ 117
3.1. Program na stronie internetowej ............................................................................118
3.1.1. Aplet jako program .....................................................................................118
3.1.2. Osadzenie obiektu na stronie ......................................................................119
3.1.3. Wersja Javy w przeglądarce ........................................................................122
3.2. Predefiniowane składowe apletu ...........................................................................123
3.2.1. Inicjacja apletu ............................................................................................124
3.2.2. Wstrzymanie i wznowienie pracy ...............................................................125
3.2.3. Zamykanie okna przeglądarki .....................................................................125
3.2.4. Wygląd i jego odświeżanie .........................................................................126
3.3. Komunikacja ze światem zewnętrznym ................................................................130
3.3.1. Wyprowadzanie informacji tekstowych ......................................................130
3.3.2. Okienko dialogowe .....................................................................................132
3.3.3. Pobieranie parametrów z pliku HTML .......................................................135
3.3.4. Pobieranie i odtwarzanie plików z serwera .................................................136
3.3.5. Komunikacja między apletami ....................................................................137
3.3.6. Pobieranie informacji z linii adresu ............................................................140
3.4. Aplet a JavaScript ..................................................................................................142
3.4.1. Wywołanie funkcji JavaScript z apletu .......................................................143
3.4.2. Bezpośrednie użycie JavaScriptu ................................................................145
3.4.3. Obsługa rejestru przeglądarki .....................................................................146
3.4.4. Wywołanie Javy z JavaScriptu ...................................................................148
3.5. Aplet jako samodzielna aplikacja ..........................................................................150
3.6. Ograniczenia w apletach .......................................................................................151
3.7. Podsumowanie .......................................................................................................152
Rozdział 4. Programowanie sterowane zdarzeniami .......................................... 153
4.1. Zarys nowej idei ....................................................................................................154
4.2. Klasyczna obsługa zdarzeń ...................................................................................155
4.2.1. Usuwanie klas anonimowych ......................................................................158
4.2.2. Obsługa zdarzeń poza klasą ........................................................................161
4.3. Współdzielenie obiektów nasłuchujących .............................................................163
4.4. Zdarzenia standardowe ..........................................................................................165
4.4.1. Zdarzenie action ..........................................................................................166
4.4.2. Zdarzenie item .............................................................................................169
4.4.3. Zdarzenie adjustment ..................................................................................170
4.4.4. Zdarzenie text ..............................................................................................171
4.4.5. Zdarzenia window .......................................................................................171
4.4.6. Zdarzenia component ..................................................................................172
4.4.7. Zdarzenia mouse .........................................................................................173
4.4.8. Zdarzenia mouseMotion .............................................................................174
4.4.9. Zdarzenia key ..............................................................................................176
4.4.10. Zdarzenia focus ...........................................................................................178
4.4.11. Zdarzenia container ....................................................................................180
4.4.12. Usuwanie obiektów nasłuchujących ...........................................................180
4.4.13. Powiązanie obiektów ze zdarzeniami .........................................................181
4.5. Zdarzenia z parametrem ........................................................................................183
4.5.1 Identyfikacja miejsca pochodzenia komunikatu ..........................................183
4.5.2. Wyniesienie własnych parametrów poza klasę ...........................................186
4.6. Łańcuchy zdarzeń ..................................................................................................188
4.7.
Listener kontra Adapter .........................................................................................189
4.8. Obsługa w klasie pochodnej ..................................................................................190
4.8.1. Obsługa zdarzeń w klasie ............................................................................190
4.8.2. Obiekt z wewnętrzną obsługą .....................................................................191
6
Java. Programowanie obiektowe
4.8.3. Rzadko stosowana metoda ..........................................................................192
4.8.4. Powiązanie klas i zdarzeń ...........................................................................193
4.8.5. Wady i zalety wewnętrznej obsługi ............................................................194
4.9. Zaszłości w obsłudze zdarzeń ...............................................................................195
4.10. Podsumowanie ......................................................................................................196
Rozdział 5. Obsługa wyjątków ......................................................................... 197
5.1. Obsługa wyjątków przez program .........................................................................198
5.1.1. Wyjątek jako obiekt ....................................................................................198
5.1.2. Konstrukcja podstawowa try – catch ..........................................................202
5.1.3. Przechwytywanie różnych wyjątków ..........................................................203
5.1.4. Zagnieżdżanie obsługi wyjątków ................................................................204
5.1.5. Słowo kluczowe finally ...............................................................................206
5.1.6. Obsługa wyjątków poza metodą .................................................................208
5.1.7. Programowe generowanie wyjątków ..........................................................210
5.1.8. Wielokrotna obsługa tego samego wyjątku ................................................210
5.2. Własne typy wyjątków ..........................................................................................212
5.3. Obsługa wyjątków przez JVM ..............................................................................214
5.4. Podsumowanie .......................................................................................................217
Rozdział 6. Programowanie wielowątkowe ...................................................... 219
6.1. Techniczna strona wielowątkowości .....................................................................220
6.2. Podstawy realizacji wątków ..................................................................................222
6.2.1. Obiekty zarządzające wątkami ....................................................................222
6.2.2. Obiekty-wątki ..............................................................................................223
6.3. Tworzenie klas wątków .........................................................................................223
6.4. Zarządzanie wątkami .............................................................................................225
6.4.1. Uruchomienie i zatrzymanie wątku ............................................................225
6.4.2. Wstrzymanie pracy wątku ...........................................................................226
6.4.3. Wątki a działalność główna ........................................................................227
6.4.4. Zawieszenie pracy wątku ............................................................................228
6.4.5. Inteligentne wstrzymanie pracy ..................................................................229
6.4.6. Wymuszenie przełączenia wątku ................................................................231
6.4.7. Priorytety wątków .......................................................................................233
6.5. Synchronizacja wątków .........................................................................................236
6.5.1. Praca synchroniczna ....................................................................................236
6.5.2. Przyczyny synchronizacji metod ................................................................237
6.5.3. Metody różnego typu ..................................................................................240
6.5.4. Synchronizacja metod asynchronicznych ...................................................242
6.5.5. Wzajemna blokada ......................................................................................242
6.5.6. Przerywanie metod synchronizowanych .....................................................244
6.6. Podsumowanie .......................................................................................................246
Słowo końcowe ............................................................................ 247
Literatura ..................................................................................... 249
Skorowidz ..................................................................................... 251
[ Pobierz całość w formacie PDF ]