Java Programowanie obiektowe.pdf

IDZ DO

PRZYK£ADOW Y ROZDZIA£

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

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

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

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

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika: