Java. Programowanie obiektowe

8/6/2019 Java. Programowanie obiektowe

1/89

Wydawnictwo Helion

. Chopina 6

4-100 Gliwice

l. (32)230-98-63

mail: [email protected]

PRZYKADOWY ROZDZIAPRZYKADOWY ROZDZIA

IDZ DOIDZ DO

ZAMW DRUKOWANY KATALOGZAMW DRUKOWANY KATALOG

KATALOG KSIEKKATALOG KSIEK

TWJ KOSZYKTWJ KOSZYK

CENNIK I INFORMACJECENNIK I INFORMACJE

ZAMW INFORMACJEO NOWOCIACH

ZAMW INFORMACJEO NOWOCIACH

ZAMW CENNIKZAMW CENNIK

CZYTELNIACZYTELNIA

FRAGMENTY KSIEK ONLINEFRAGMENTY KSIEK ONLINE

SPIS TRECISPIS TRECI

DODAJ DO KOSZYKADODAJ DO KOSZYKA

KATALOG ONLINEKATALOG ONLINE

Java. ProgramowanieobiektoweAutor: Marek Wierzbicki

ISBN: 83-246-0290-9

Format: B5, stron: 264

Doskonae wprowadzenie w wiat obiektowoci

Podstawowe zasady programowania obiektowego

Programowanie sterowane zdarzeniami

Obsuga wyjtkw i wielowtkowoci

Programowanie obiektowe to technologia, ktra zdobya ju bardzo mocn pozycj

wrd twrcw oprogramowania. Nadal jednak wielu programistw, ktrzy zdobywali

dowiadczenie, uywajc jzykw proceduralnych, ma problemy z jej zrozumieniem

i wszechstronnym stosowaniem. Wiele jzykw programowania okrelanych mianem

obiektowe wywodzi si z jzykw proceduralnych, co ogranicza moliwoci

wykorzystywania wszystkich zalet obiektowoci. Ogranicze tych pozbawiona jestJava stworzony od podstaw, nowoczesny, bezpieczny, niezaleny od typu komputera

i systemu operacyjnego, w peni obiektowy jzyk programowania.

Ksika Java. Programowanie obiektowe opisuje wszystkie aspekty programowania

obiektowego w Javie. Pocztkujcy uytkownicy tego jzyka znajd w niej wyjanienia

nawet najbardziej skomplikowanych mechanizmw obiektowoci, a ci, ktrzy posiadaj

ju pewne dowiadczenie, mog wykorzysta j w charakterze podrcznego

kompendium wiedzy. Mona znale w niej omwienie zarwno podstawowych

zagadnie, jak i zaawansowanych technik obsugi bdw, programowania

wielowtkowego i sterowanego zdarzeniami. W ksice przedstawiono rwnie metody

tworzenia wydajnie dziaajcych programw, ktre do uruchomienia nie wymagajmaszyn o potnej mocy obliczeniowej.

Cechy programowania obiektowego

Obiektowo w Javie

Tworzenie i stosowanie klas i obiektw

Budowanie pakietw

Tworzenie apletw

Komunikacja apletw ze skryptami Java Script

Obiekty nasuchujce i obsuga zdarze

Przechwytywanie wyjtkw

Synchronizacja wtkwPoznaj moliwoci technologii obiektowej w praktyce
mailto:[email protected]://helion.pl/zamow_katalog.htmhttp://helion.pl/zamow_katalog.htmhttp://helion.pl/emaile.cgihttp://helion.pl/emaile.cgihttp://helion.pl/emaile.cgihttp://helion.pl/emaile.cgihttp://helion.pl/cennik.htmhttp://helion.pl/cennik.htmhttp://helion.pl/online.htmhttp://helion.pl/online.htmhttp://helion.pl/zakupy/add.cgi?id=japrobhttp://helion.pl/zakupy/add.cgi?id=japrobhttp://helion.pl/katalog.htmhttp://helion.pl/katalog.htmhttp://helion.pl/ksiazki/japrob.htmmailto:[email protected]://helion.pl/online.htmhttp://helion.pl/cennik.htmhttp://helion.pl/emaile.cgihttp://helion.pl/zakupy/add.cgi?id=japrobhttp://helion.pl/katalog.htmhttp://helion.pl/zamow_katalog.htmhttp://helion.pl/


2/89

Od autora ......................................................................................... 7

Rozdzia 1. Wprowadzenie ................................................................................ 111.1. Oglne cechy programowania obiektowego ...........................................................12

1.1.1. Hermetyzacja ................................................................................................13

1.1.2. Dziedziczenie cech ........................................................................................141.1.3. Dziedziczenie metod i polimorfizm ..............................................................16

1.1.4. Nowa jakodziaania ..................................................................................17

1.2. Cechy szczeglne obiektowoci Javy ......................................................................181.2.1. Obiekty w Javie .............................................................................................21

1.2.2. Deklaracje dostpnoci .................................................................................221.2.3. Klasy wewntrzne i zewntrzne ....................................................................22

1.2.4. Klasy abstrakcyjne ........................................................................................231.2.5. Interfejsy .......................................................................................................24

1.2.6. Implementacje ...............................................................................................251.2.7. Klasy finalne .................................................................................................25

1.2.8. Metody i klasy statyczne ...............................................................................261.2.9. Klasy anonimowe ..........................................................................................27

1.2.10. Obiekty refleksyjne .......................................................................................281.2.11. Zdalne wykonywanie metod .........................................................................28

1.2.12. Pakiety ..........................................................................................................29

1.2.13. Zarzdzanie pamici ...................................................................................301.2.14. Konwersja typw ..........................................................................................30

1.3. Podsumowanie .........................................................................................................31

Rozdzia 2. Klasy i obiekty w Javie .................................................................... 33

2.1. Klasy ........................................................................................................................332.1.1. Tworzenie klas ..............................................................................................33

2.1.2. Pola ................................................................................................................352.1.3. Metody ..........................................................................................................35

2.1.4. Hermetyzacja i modyfikator private .............................................................362.1.5. Przecianie metod ....................................................................................... 37

2.1.6. Sowo kluczowe this ..................................................................................... 382.1.7. Konstruktor ...................................................................................................39

2.1.8. Przecianie konstruktorw ..........................................................................40

2.1.9. Dziedziczenie ................................................................................................432.1.10. Inicjator klasy i obiektu ................................................................................44

2.1.11. Kolejno inicjacji klas .................................................................................47

2.1.12. Destruktor .....................................................................................................50


3/89

4 Java. Programowanie obiektowe

2.1.13. Przykrywanie metod .....................................................................................512.1.14. Odwoanie do klas nadrzdnych ...................................................................522.1.15. Odwoanie do pl klas nadrzdnych .............................................................532.1.16. Klasy abstrakcyjne ........................................................................................54

2.2. Obiekty ....................................................................................................................55

2.2.1. Rozwaania o adresie ....................................................................................552.2.2. Jawne uycie obiektw .................................................................................562.2.3. Kopiowanie obiektw ...................................................................................582.2.4. Niejawne uywanie obiektw .......................................................................592.2.5. Typ zmiennej i obiektu. Operator instanceof ................................................602.2.6. Efekty polimorfizmu .....................................................................................62

2.3. Klasy wewntrzne i lokalne ....................................................................................632.3.1. Dostp do zmiennych klasy zawierajcej .....................................................652.3.2. Polimorfizm i zmienne klasy zawierajcej ...................................................662.3.3. Zmienne lokalne w klasie lokalnej ................................................................682.3.4. this w klasach wewntrznych ........................................................................692.3.5. Korzystanie z klas wewntrznych .................................................................71

2.4. Interfejsy ..................................................................................................................732.4.1. Definicja interfejsu ........................................................................................742.4.2. Implementacje ...............................................................................................742.4.3. Zastosowanie interfejsw ..............................................................................762.4.4. Stae symboliczne ......................................................................................... 772.4.5. Trochkodu w interfejsie .............................................................................792.4.6. Dziedziczenie interfejsw .............................................................................812.4.7. Egzemplarz interfejsu ...................................................................................83

2.5. Klasy anonimowe ....................................................................................................842.5.1. Klasyczne uycie klasy anonimowej ............................................................852.5.2. Jawna klasa anonimowa ................................................................................872.5.3. Konstruktor klasy anonimowej .....................................................................88

2.6. Obiekty refleksyjne .................................................................................................892.6.1. Obiekt tworzony refleksyjnie ........................................................................892.6.2. Oglne rozpoznawanie klasy ........................................................................912.6.3. Przykad uycia refleksji ...............................................................................922.6.4. Zwizek refleksji z obiektowoci ................................................................94

2.7. Metody .....................................................................................................................952.7.1. Zwracanie wartoci przez metod .................................................................952.7.2. Przekazywanie parametrw przez warto ...................................................962.7.3. Zmiana wartoci parametru ...........................................................................972.7.4. Metody ze zmiennliczbparametrw ........................................................992.7.5. Zakres nazw zmiennych ..............................................................................100

2.8. Pakiety ...................................................................................................................1012.8.1. Tworzenie pakietw ....................................................................................1012.8.2. Uywanie pakietw .....................................................................................1032.8.3. Lista pakietw .............................................................................................104

2.9. Modyfikatory .........................................................................................................1052.9.1. Modyfikatory dostpu .................................................................................1062.9.2. Pokrywanie modyfikatorw dostpu ..........................................................1072.9.3. Metody i pola statyczne ..............................................................................1092.9.4. Pola finalne .................................................................................................1112.9.5. Metody i klasy finalne .................................................................................1122.9.6. Pola podlegajce zmianie ............................................................................1132.9.7. Metody synchronizowane ...........................................................................1132.9.8. Pola ulotne ...................................................................................................1142.9.9. Metody rodzime ..........................................................................................114

2.10. Podsumowanie ...................................................................................................... 115


4/89

Spis treci 5

Rozdzia 3. Aplet jako obiekt na stronie HTML ................................................ 1173.1. Program na stronie internetowej ............................................................................118

3.1.1. Aplet jako program ..................................................................................... 118

3.1.2. Osadzenie obiektu na stronie ...................................................................... 1193.1.3. Wersja Javy w przegldarce ........................................................................122

3.2. Predefiniowane skadowe apletu ...........................................................................1233.2.1. Inicjacja apletu ............................................................................................124

3.2.2. Wstrzymanie i wznowienie pracy ...............................................................125

3.2.3. Zamykanie okna przegldarki .....................................................................1253.2.4. Wygld i jego odwieanie .........................................................................126

3.3. Komunikacja ze wiatem zewntrznym ................................................................1303.3.1. Wyprowadzanie informacji tekstowych ......................................................130

3.3.2. Okienko dialogowe .....................................................................................1323.3.3. Pobieranie parametrw z pliku HTML ....................................................... 135

3.3.4. Pobieranie i odtwarzanie plikw z serwera .................................................1363.3.5. Komunikacja midzy apletami ....................................................................137

3.3.6. Pobieranie informacji z linii adresu ............................................................1403.4. Aplet a JavaScript ..................................................................................................142

3.4.1. Wywoanie funkcji JavaScript z apletu .......................................................143

3.4.2. Bezporednie uycie JavaScriptu ................................................................1453.4.3. Obsuga rejestru przegldarki .....................................................................146

3.4.4. Wywoanie Javy z JavaScriptu ................................................................... 1483.5. Aplet jako samodzielna aplikacja ..........................................................................150

3.6. Ograniczenia w apletach ....................................................................................... 1513.7. Podsumowanie .......................................................................................................152

Rozdzia 4. Programowanie sterowane zdarzeniami .......................................... 1534.1. Zarys nowej idei ....................................................................................................154

4.2. Klasyczna obsuga zdarze ...................................................................................155

4.2.1. Usuwanie klas anonimowych ......................................................................1584.2.2. Obsuga zdarzepoza klas ........................................................................161

4.3. Wspdzielenie obiektw nasuchujcych .............................................................163

4.4. Zdarzenia standardowe ..........................................................................................165

4.4.1. Zdarzenie action ..........................................................................................1664.4.2. Zdarzenie item .............................................................................................169

4.4.3. Zdarzenie adjustment ..................................................................................1704.4.4. Zdarzenie text ..............................................................................................171

4.4.5. Zdarzenia window .......................................................................................1714.4.6. Zdarzenia component ..................................................................................172

4.4.7. Zdarzenia mouse .........................................................................................1734.4.8. Zdarzenia mouseMotion ............................................................................. 174

4.4.9. Zdarzenia key ..............................................................................................1764.4.10. Zdarzenia focus ...........................................................................................178

4.4.11. Zdarzenia container .................................................................................... 1804.4.12. Usuwanie obiektw nasuchujcych ...........................................................180

4.4.13. Powizanie obiektw ze zdarzeniami .........................................................1814.5. Zdarzenia z parametrem ........................................................................................183

4.5.1 Identyfikacja miejsca pochodzenia komunikatu ..........................................1834.5.2. Wyniesienie wasnych parametrw poza klas ...........................................186

4.6. acuchy zdarze ..................................................................................................188

4.7.Listener kontra Adapter .........................................................................................1894.8. Obsuga w klasie pochodnej ..................................................................................190

4.8.1. Obsuga zdarze w klasie ............................................................................190

4.8.2. Obiekt z wewntrznobsug .....................................................................191


5/89


4.8.3. Rzadko stosowana metoda ..........................................................................192

4.8.4. Powizanie klas i zdarze ...........................................................................1934.8.5. Wady i zalety wewntrznej obsugi ............................................................194

4.9. Zaszoci w obsudze zdarze ...............................................................................195

4.10. Podsumowanie ...................................................................................................... 196

Rozdzia 5. Obsuga wyjtkw ......................................................................... 1975.1. Obsuga wyjtkw przez program .........................................................................198

5.1.1. Wyjtek jako obiekt ....................................................................................198

5.1.2. Konstrukcja podstawowa try catch ..........................................................2025.1.3. Przechwytywanie rnych wyjtkw ..........................................................203

5.1.4. Zagniedanie obsugi wyjtkw ................................................................2045.1.5. Sowo kluczowe finally ...............................................................................206

5.1.6. Obsuga wyjtkw poza metod .................................................................2085.1.7. Programowe generowanie wyjtkw ..........................................................210

5.1.8. Wielokrotna obsuga tego samego wyjtku ................................................2105.2. Wasne typy wyjtkw ..........................................................................................212

5.3. Obsuga wyjtkw przez JVM .............................................................................. 2145.4. Podsumowanie .......................................................................................................217

Rozdzia 6. Programowanie wielowtkowe ...................................................... 2196.1. Techniczna strona wielowtkowoci .....................................................................2206.2. Podstawy realizacji wtkw ..................................................................................222

6.2.1. Obiekty zarzdzajce wtkami ....................................................................2226.2.2. Obiekty-wtki ..............................................................................................223

6.3. Tworzenie klas wtkw .........................................................................................2236.4. Zarzdzanie wtkami .............................................................................................225

6.4.1. Uruchomienie i zatrzymanie wtku ............................................................2256.4.2. Wstrzymanie pracy wtku ...........................................................................226

6.4.3. Wtki a dziaalnogwna ........................................................................227

6.4.4. Zawieszenie pracy wtku ............................................................................2286.4.5. Inteligentne wstrzymanie pracy ..................................................................229

6.4.6. Wymuszenie przeczenia wtku ................................................................2316.4.7. Priorytety wtkw .......................................................................................233

6.5. Synchronizacja wtkw .........................................................................................2366.5.1. Praca synchroniczna ....................................................................................236

6.5.2. Przyczyny synchronizacji metod ................................................................2376.5.3. Metody rnego typu ..................................................................................240

6.5.4. Synchronizacja metod asynchronicznych ................................................... 2426.5.5. Wzajemna blokada ......................................................................................242

6.5.6. Przerywanie metod synchronizowanych .....................................................2446.6. Podsumowanie .......................................................................................................246

Sowo kocowe ............................................................................ 247

Literatura ..................................................................................... 249

Skorowidz ..................................................................................... 251


6/89

Rozdzia 2.

Poprzedni rozdziawprowadzaoglnie pojtideprogramowania obiektowego orazjej modyfikacje na potrzeby Javy. W tym rozdziale zajmsitym samym problemem,ale tutaj pokarodki realizacji idei opisanych wczeniej. Bdziesz mgdowiedziesi, jak w praktyce realizuje siprogramowanie obiektowe z uyciem kodu rdowegow Javie. Poszczeglne konstrukcje jzyka s omwione z perspektywy kodowaniaoraz dziaania wirtualnej maszyny Javy, czyli JVM (Java Virtual Machine). Pomijamwikszorozwaateoretycznych nad cechami poszczeglnych konstrukcji, ktreopisaem wczeniej, dlatego licz, e w dostateczny sposb zapoznaesiz treci

poprzedniego rozdziau.

2.1. Klasy

Klasy okrelajposta, struktur i dziaanie obiektw, ktre segzemplarzami klas.W zwizku z zastosowaniem w Javie skrajnie ortodoksyjnego podejcia program na-

pisany z uyciem tego jzyka musi mie, poza kilkoma wyjtkami (czyli prostymipodstawowymi typami danych), struktur oraz dziaanie lub algorytm, ktry wyko-nuje, zaprojektowane z uyciem klas (a zrealizowane z uyciem ich egzemplarzy,czyli obiektw).

2.1.1. Tworzenie klas

Najprostsza moliwa do stworzenia klasa ma posta:

class Simple {}

Charakteryzuje jsowo kluczowe class, nazwa klasy (w tym wypadku Simple) orazpara nawiasw klamrowych, ktre reprezentujjej ciao (w tym przypadku spuste).Klasa ta musi byumieszczona w pliku Simple.java. Tak utworzony plik moe zosta

poddany poprawnej kompilacji i stanowizupenie poprawn(chocakiem nieprzydatn)klasJavy. Naley pamita, e kada klasa publiczna musi byzapisana w osobnym

pliku, ktrego nazwa musi by dokadnie taka sama (oczywicie plus rozszerzenie


7/89


.java) jak nazwa klasy zdefiniowanej wewntrz (wcznie z rozrnieniem na due i maelitery). Teoria mwi, e nazwy klas mogzawieratak zwane znaki narodowe, ale zewzgldu na rne standardy kodowania (nawet w obrbie jednego systemu operacyj-nego) nie powinno sistosowaliter innych niaciskie.

Definicja klasy podstawowej musi bytworzona wedug szablonu zaprezentowanegona listingu 2.1 (elementy ujte w nawiasy kwadratowe sopcjonalne i nie muszwy-stpowa).

Listing 2.1.Szablon definicji klasy

[modyfikator] class NazwaKlasy { [modyfikator] typ nazwa_pola_1; ... [modyfikator] typ nazwa_pola_k;

[modyfikator] typ nazwa_metody_1([lista_parametrw]) { ciao_metody_1 } ... [modyfikator] typ nazwa_metody_L([lista_parametrw]) { ciao_metody_L }}

Klasa moe posiadadowolnliczbpl i metod (w tym zero, nawet cznie dla pl

i metod, jak pokazaem to wczeniej w najprostszej klasie Simple).Poniej umieszczam objanienie poszczeglnych elementw zaprezentowanych w sza-

blonie na listingu 2.1.

class sowo kluczowe okrelajce definicjklasy.

NazwaKlasy identyfikator okrelajcy nazwklasy.

modyfikator sowo lub sowa kluczowe oddzielone od siebie spacjokrelajce sposb traktowania elementu, do ktrego siodnosz. Modyfikatormoe teoznaczaograniczenie lub rozszerzenie dostpu do elementu. Penewyjanienie znaczenia tego elementu jzyka znajduje siw podrozdziale 2.9.

Modyfikatory.

typ typ pola lub metody moe to bytyp prosty (byte, short, int, long,char, float, doublelub booleanoraz void tylko w odniesieniu do metody),klasa bdtablica (array) elementw jednego typu.

nazwa_pola_x identyfikator jednoznacznie okrelajcy pole konstruowanej klasy.

nazwa_metody_x identyfikator, ktry wraz z listparametrw jednoznacznieokreli metod.

lista_parametrw lista par rozdzielonych przecinkami skadajcych siz okrelenia typu i nazwy egzemplarza danego typu. Jeli nie zamierzamy

przekazado metody adnych parametrw, jej deklaracja powinna zawiera


8/89

Rozdzia 2. Klasy i obiekty w Javie 35

parpustych nawiasw. Zwracam tu uwagna odstpstwa od C++, ktrew takim przypadku powinno (zamiast pustych nawiasw) zawierasowovoid, oraz rnice w stosunku do Object Pascala niezawierajcego w takim

przypadku nawiasw.

ciaco_metody_x zbir instrukcji jzyka Java okrelajcy funkcjonalnodanej metody.

2.1.2. Pola

Pola s to miejsca, w ktrych przechowywane s informacje charakterystyczne dlacaej klasy bddla jej konkretnego egzemplarza. O polach mwi siteczasami, esto egzemplarze zmiennych nalece do konkretnego egzemplarza klasy. W prakty-ce moemy traktowapola jako lokalne zmienne danej klasy z zastrzeeniem, e za-kres ich widzialnoci i zachowania jest okrelony przez modyfikatory poszczeglnych

pl. Klasyczna deklaracja pola odbywa siwedug schematu:

[modyfikator] typ nazwa_pola_k;

Przykad klasy zawierajcej tylko dwa pola pokazany jest na listingu 2.2.

Listing 2.2.Klasa posiadajca tylko dwa pola

class Point { int x; // pooenie na osi 0X int y; // pooenie na osi 0Y}

W przykadzie tym pola s zmiennymi prostymi. Nie ma jednak adnych przeciw-wskaza, eby byy zmiennymi zoonymi, w tym rwnieobiektami.

2.1.3. Metody

Inaczej ni inne jzyki obiektowe takie jak C++ czy Object Pascal, Java nie tylkogromadzi wszystkie informacje w plikach jednego rodzaju (tekstowych, z rozszerze-

niem .java), ale rwniestara sije przechowywaw moliwie najbardziej skoncen-trowany sposb. W C++ istniejpliki nagwkowe, ktre przechowujstrukturobiektw,i waciwe pliki z programem przechowujce midzy innymi obiekty. W Object Pascaluinformacje te sco prawda zawarte w jednym pliku, jednak czjest w sekcji inter-face, czw implementation. W Javie wszystko jest w jednym miejscu. Caa infor-macja o metodzie zawarta jest tuprzed jej ciaem, tak jak to widana listingu 2.3.

Listing 2.3.Szablon definicji metody

[modyfikator] typ nazwa_metody([lista_parametrw]){ // blok instrukcji}


9/89


Jeli typ metody jest rny od void(czyli funkcja zwraca jakwarto), powinna onabyzakoczona wierszem:

return wyliczonaWartosc;

gdzie wyliczonaWartoscmusi bytakiego samego typu jak typ metody.

Po zaprezentowaniu schematu tworzenia klas mog przystpi do przedstawieniaprzykadu prostej klasy, ktra umoliwia przechowywanie informacji o pooeniupunktu na paszczynie wraz z metodami umoliwiajcymi okrelenie pooenia po-cztkowego punktu i przemieszczenia go. Klasa ta pokazana jest na listingu 2.4.

Listing 2.4.Klasa opisujca punkt

class Point { int x; // pooenie na osi 0X int y; // pooenie na osi 0Y

// ustawienie nowej pozycji public void newPosition(int newX, int newY) { x = newX; y = newY; } // przemieszczenie punktu public void changePosition(int dX, int dY) { x = x+dX; y = y+dY; }}

W dalszej czci tego rozdziau bd rozszerzadefinicj tej klasy i precyzowa jejznaczenie.

2.1.4. Hermetyzacja i modyfikator private

Wprowadzajc ide programowania obiektowego, zwracaem uwag na jej podsta-wowcech(i zarazem bardzo wanzalet), czyli hermetyzacj. Klasa (a wraz z niobiekt) miaa gromadziw jednym miejscu dane i procedury ich obsugi. Jednak miao to

byzgromadzone w taki sposb, aby osoba uywajca obiektu miaa jak najmniejszydostp do danych (tylko do tych niezbdnych). Miao to zapewnizarwno zmniej-

szenie liczby bdw popenianych w czasie kodowania, jak i podniesienie przejrzy-stoci programu. Przedstawiona wczeniej klasa Point nie stanowia idealnej repre-zentacji hermetycznej klasy, gdy udostpniaa na zewntrz wszystkie, a nie tylkoniezbdne elementy. Aby uniemoliwidostp do pl, ktre w idei klasy nie musz

bydostpne z zewntrz, naley je oznaczymodyfikatorem private. Na listingu 2.5przedstawiam poprawion, bardziej hermetycznwersjklasy Point.

Listing 2.5.Poprawiona klasa opisujca punkt

class Point { private int x; // pooenie na osi 0X private int y; // pooenie na osi 0Y


10/89


// odczyt wartoci public int getpb return x; } public int getYpb

return y; } // ustawienie nowej pozycji public void newPosition(int newX, int newY) { x = newX; y = newY; } // przemieszczenie punktu public void changePosition(int dX, int dY) { x = x+dX; y = y+dY; }}

Na listingu 2.5 wytuciem rnice w stosunku do wczeniejszej wersji klasy, czyliukrycie bezporednich wartoci xiyoraz udostpnienie w zamian ich wartoci przezmetody getX i getY. Zaleta takiego rozwizania jest widoczna. Nie mona, nawet

przez przypadek, odwoasibezporednio do xiy, dziki czemu nie moe nastpiprzypadkowa ich modyfikacja. Aby je odczyta, trzeba jawnie wywoagetXlub getY.Aby je ustawi, trzeba jawnie wywoanewPosition(mona teutworzymetody setXi setY, aby ustawia te parametry pojedynczo). Dopiero tak skonstruowana klasaspenia warunki hermetyzacji.

2.1.5. Przecianie metodIstniejsytuacje, w ktrych niektrzy programici uwaaj, e wskazane jest, abymona byo utworzykilka metod o tych samych nazwach, lecz o rnym zestawie

parametrw. Jako przykad mona pokazakolejne rozszerzenie naszej klasy Pointo nowwersjmetody newPosition. Rozszerzenie to pokazane jest na listingu 2.6.

Listing 2.6.Kolejna wersja klasy opisujcej punkt


// ustawienie nowej pozycji public void newPosition(int newX, int newY) { x = newX; y = newY; } // ustawienie nowej pozycji na (0,0) public void newPosition() { x = 0; y = 0; }

// pozostae metody klasy Point // ...

}


11/89


Pokazana na listingu 2.6 klasa ma dwie metody newPosition. Jedna, wywoana z pa-rametrami, ustawia wsprzdne punktu na wartoci podane jako parametry. Druga,

bez parametrw, ustawia wsprzdne punktu na wartodomyln(0,0). Mona pr-bowawyobrazisobie sytuacj, w ktrej nie da sizastosowainnego rozwizania.

Czsto jednak przecianie nie jest konieczne. Osobicie uwaam, e kiedy tylko niema takiej potrzeby, nie powinno sigo stosowa. Jednak w standardowych bibliote-kach Javy wiele funkcji jest przecionych, co powoduje, e programici chtnietrzymaj si takiego standardu kodowania. Na przykad w projektowanej przez nasklasie zamiast przeciania metody newPosition mona by zastosowa dwie rnemetody newPositionoraz defaultPosition. Jeeli jednak decydujemy sina prze-cianie metod, powinnimy pamitao nastpujcych uwagach:

Metody rozrniane swycznie na podstawie liczby i typw przekazywanychdo nich parametrw. Wywoanie metody powinno odbysiz waciwymzestawem parametrw, gdyw przeciwnym wypadku kompilator zgosi bd.

Metody nie srozrniane na podstawie nazw parametrw formalnych,w zwizku z tym prba stworzenia dwch metod o tym samym zestawietypw parametrw i rnych ich nazwach zakoczy sibdem.

Metody nie srwnierozrniane na podstawie typw zwracanej wartoci.W zwizku z tym dwie metody o takim samym zestawie parametrw, leczo rnym typie zwracanego wyniku zostanpotraktowane jak jedna metodai kompilator rwniezgosi bd.

Jak wszdzie, w Javie wielkoliter ma znaczenie. W zwizku z tym istnieniemetod newPositioni NewPositionnie jest adnym przecieniem, gdymajone rne nazwy (wedug mnie stosowanie nazw rnicych siwycznie

wielkociliter to bardzo zy pomys).

2.1.6. Sowo kluczowe this

Java zawiera w swojej skadni ciekawe, chopozornie nieprzydatne sowo this. Z punktuwidzenia formalnego wszystkie odwoania do wasnych pl i metod sdokonywanew stosunku do tej klasy, w ktrej siznajdujemy (czyli po angielsku wanie this).Podobny mechanizm stosowany jest na przykad w Object Pascalu, ktry domylniezakada, e wszystkie nieprzekierowane odwoania wykonywane s w stosunku dosiebie (w Pascalu do przekierowauywa si sowa Self). Przykad wczeniej uy-

wanej metody newPositionmoe by(a w zasadzie z punktu widzenia skrajnego for-malizmu powinien by) zapisany w postaci zaprezentowanej na listingu 2.7.

Listing 2.7.Bardzo formalna definicja metody w klasie opisujcej punkt

public void newPosition(int newX, int newY) { this.x = newX; this.y = newY;}

Oczywicie nikt tego nie robi, gdypoza niepotrzebnym nakadem pracy nie zyskujesi w ten sposb adnego ciekawego efektu. Nie zawsze jednak stosowanie tego

przedrostka nie daje adnego efektu. Istniejsytuacje, kiedy kod rdowy programu


12/89


bez sowa thisnie determinuje poprawnie elementu, do ktrego zamierzalimy siodwoa. Dzieje si tak wtedy, gdy parametry metody maj takie same nazwy jak

pola klasy. Na listingu 2.8 przedstawiam zmodyfikowanwersjmetody newPosition,w ktrej uycie sowa thisjest jujak najbardziej uzasadnione.

Listing 2.8.Uzasadnione uycie sowa this w klasie opisujcej punkt

public void newPosition(int x, int y) { this.x = x; this.y = y;}

Patrick Naughton, jeden ze wsptwrcw Javy, uwaa, e taka konstrukcja upraszczatekst rdowy oraz czyni go bardziej przejrzystym i mniej podatnym na bdy. W zwizkuz tak tez stawianprzez wspautora jzyka wiele osb nagminnie stosuje takiekonstrukcje. Wedug mnie jest to niepotrzebny manieryzm, ktry zaciemnia obraz sytuacjii jest przyczynduej liczby drobnych i zupenie niepotrzebnych bdw. Warto po-

patrzena hipotetycznmetodnewPositionpokazanna listingu 2.9, ktra przeliczaprzed ustawieniem wartopooenia z cali na centymetry, aby mona byo zobaczy,e atwo jest sipomyli, stosujc te same nazwy dla parametrw i pl klasy.

Listing 2.9.Przykad popenienia bdu zasigu zmiennych

classFloatPoint { float x, y; public void newPosition(float x, float y) { float xcm, ycm; xcm = 2.51*x;

ycm = 2.51*y; x = xcm; // zy zakres y = ycm; // zy zakres }}

Oczywicie kompilator nie zgosi adnego bdu, gdy konstrukcja jest jak najbar-dziej poprawna, a my bdziemy sizastanawia, dlaczego pola obiektu nie sinicjo-wane we waciwy sposb. Otw wierszach oznaczonych na listingu 2.9 komenta-rzem zy zakres podstawiamy wartoci do zmiennych, ktre posuyy nam do

przekazania wartoci do metody, a ktre nie swidoczne na zewntrz od niej (przy-

kryy nazwy pl).

Rozszerzenie uycia sowa this pokazaem w paragrafach 2.1.8. Przecienie kon-struktorw, 2.4.3. Zastosowanie interfejsw oraz 2.3.4. this w klasach wewntrznych.

2.1.7. Konstruktor

Mimo izaprezentowana klasa Pointjest w peni funkcjonalna w zakresie, jakiego odniej oczekujemy, w praktyce brakuje jej elementu, ktry znacznie uatwiby jej (i ka-dej innej klasy) wykorzystanie. Otbezporednio po utworzeniu obiektu, czyli eg-

zemplarza tej klasy (co przedstawiw dalszej czci tego rozdziau), pooenie nowego


13/89


punktu jest nieokrelone. Dopiero po uyciu metody newPosition, ktra jawnie dekla-ruje nowe pooenie punktu, przestaje ono bynieokrelone, a zaczyna bytakie, jakto zostao w niej ustawione. W zwizku z tym po kadorazowym utworzeniu takiegoobiektu naleaoby pamitao zainicjowaniu jego pooenia. Znacznie wygodniej

byoby, gdyby inicjacja pooenia punktu odbywaa siautomatycznie w czasie two-rzenia obiektu. Jest to moliwe, pod warunkiem e skorzystamy z moliwoci stoso-wania specjalnej metody zwanej konstruktorem, wywoywanej automatycznie w cza-sie tworzenia egzemplarza klasy. Od zwykej metody odrniaj konstruktor dwiekwestie nazwa zgodna z nazwklasy oraz brak typu. W stosunku do konstruktoramona stosowadeklaracje zasigu, przy czym dobra praktyka sugeruje, aby zasigwidzialnoci konstruktora bydokadnie taki sam jak samej klasy. Byoby to bowiemduym bdem, gdyby klasa bya widziana, a jej konstruktor nie. Przykadowy kon-struktor dla klasy Pointpokazywanej wczeniej bdzie miapostazaprezentowanna listingu 2.10.

Listing 2.10.Konstruktor klasy opisujcej punkt

// konstruktor klasy Point

Point(int newX, int newY) { x = newX; y = newY;}

Brak typu w deklaracji konstruktora wynika z tego, e w praktyce zwraca on wartotypu dokadnie takiego samego jak klasa, w ktrej jest umieszczony, czyli domylnie

jego typ jest dokadnie taki jak nazwa klasy. Gdyby wic twrcy Javy chcieli bybardzopedantyczni, deklaracja konstruktora powinna wygldajak na listingu 2.11.

Listing 2.11.Hipotetyczna deklaracja konstruktora

// teoretyczna deklaracja konstruktora

// (uwaga: bdna formalnie)

PointPoint(int newX, int newY) { x = newX; y = newY;}

Na szczcie nie ma potrzeby, aby tak utrudniasobie ycie.

2.1.8. Przecianie konstruktorw

O ile przecienia metod mona unikn, stosujc rne nazwy metod (na przykaddodajc rne przyrostki), o tyle przecienie konstruktorw moe okaza si nie-zbdne. Konstruktor to specyficzna, wywoywana w czasie tworzenia obiektu metodao nazwie zgodnej z nazwklasy. Ograniczenie takie (niewystpujce na przykadw Object Pascalu, gdzie konstruktor moe miedowolnnazw) wymusza stosowanie

przecienia konstruktorw, jeli chcemy korzystaz nich w sposb bardziej uniwer-salny. Jako przykad wemy pokazywanwczeniej klasPoint. Sugerujdodanie doniej drugiego konstruktora bez parametrw, ktry bdzie ustawia pooenie punktuna pocztku ukadu wsprzdnych (0,0), tak jak na listingu 2.12.


14/89


Listing 2.12.Deklaracja dwch konstruktorw o tej samej nazwie


// pierwszy konstruktor klasy Point Point() { x = 0; y = 0; } // drugi konstruktor klasy Point Point(int newX, int newY) { x = newX; y = newY; } //...}

W tym przypadku nie jest moliwe ominicie przecienia ze wzgldu na koniecz-nozastosowania dla obu konstruktorw tej samej nazwy (czyli Point).

Udogodnienie wprowadzone przez mechanizm przeciania metod wprowadza bocz-nymi drzwiami moliwozastosowania metod nazywajcych sitak samo jak klasy.

Na pierwszy rzut oka wydaje si, e bdziemy mieli do czynienia z konstruktorem,chow rzeczywistoci bdzie to zwyka metoda o nazwie takiej jak klasa. W szcze-glnym przypadku moemy wic zastosowakonstrukcjpokazanna listingu 2.13.

Listing 2.13.Deklaracja metody i klasy o tej samej nazwie

class Klasa { Klasa(){ /* konstruktor Klasa*/} // metoda o nazwie Klasa: public int Klasa(int i) { return i; }}

Uycie konstruktora i metody (trochwybiegam tu w przyszo, lecz mam nadziej,e mi to wybaczysz) bdzie miao postajak na listingu 2.14.

Listing 2.14.Uycie konstruktora i metody o tej samej nazwie

// wykorzystanie konstruktora

Klasa k = new Klasa();// wykorzystanie metody

int i = k.Klasa(11);

Jakkolwiek taka konstrukcja jest moliwa, nie polecam jej ze wzgldu na wysokpo-datnona generowanie bdw w tym miejscu. Jeli uyjemy kompilatora z opcj

pedantycznej kompilacji (na przykadJIKES), w czasie przetwarzania tej konstrukcjizgosi on co do niej zastrzeenie, lecz wykona proces kompilowania. Oto przykad

bdnego uycia zaprezentowanej klasy:

Klasa k = new Klasa(11);


15/89


Na pierwszy rzut oka wydaje si, e wszystko jest w porzdku. Odwoanie takie nieskutkuje jednak wywoaniem konstruktora, tylko metody. Dlatego jak wczeniej napi-saem, nie powinno sistosowatej konstrukcji, chyba e szczeglne zaley nam nazaciemnieniu struktury programu (na przykad w celu utrudnienia dekompilacji).

Warto zauway, e stosowanie konstruktora i metody o tej samej nazwie jest pewnniecisociw stosunku do kwestii przeciania metod. Zwyke metody nie s roz-rniane na podstawie typu zwracanego wyniku. Natomiast konstruktor i metoda o tejsamej nazwie i tym samym zestawie parametrw s dla kompilatora rne. Dzikitemu moliwe jest totalne zaciemnienie kodu klasy, jak to pokazaem na listingu 2.15.

Listing 2.15.Metoda udajca domylny konstruktor

class Klasa { public int Klasa() { return 1;

}}

Pokazana na listingu 2.15 metoda umoliwia napisanie fragmentu programu zapre-zentowanego na listingu 2.16.

Listing 2.16.Uycie konstruktora i metody o takiej samej licie parametrw

// domylny, bezparametrowy konstruktor

Klasa k = new Klasa();// metoda zwracajca wynik typu int

int i = k. Klasa();

Jakkolwiek sosoby, ktre lubujsiw stosowaniu takich konstrukcji, twierdzc ejest to esencja programowania obiektowego, ja uwaam to za ze rozwizanie.

Na marginesie przecienia konstruktorw mona pokazauycie sowa kluczowegothisw formie innej, nipokazano w paragrafie 2.1.6. Sowo kluczowe this. Otodwoanie do samego tego sowa jest rwnowane odwoaniu do konstruktora klasy,w ktrej siznajdujemy. Oczywicie ma to sens jedynie w przypadku, gdy klasa makilka przecionych konstruktorw i jeden z nich, zamiast jawnie wykonywa jaki

blok instrukcji, odwouje sido innego. Na listingu 2.17 przedstawiam ten sam frag-

ment klasy Point, jednak z uyciem wywoania jednego z konstruktorw przez drugiza pomocsowa this.

Listing 2.17.Uycie sowa this zamiast konstruktora

class Point { private int x; // pooenie na osi 0X private int y; // pooenie na osi 0Y // pierwszy konstruktor klasy Point Point() { this(0,0p; } // drugi konstruktor klasy Point

Point(int newX, int newY) {


16/89


x = newX; y = newY; } //...}

Takie zastosowanie this rzeczywicie upraszcza kod rdowy i czyni go bardziejprzejrzystym.

2.1.9. Dziedziczenie

Zanim przejdziemy dalej, naley wprowadzipojcie dziedziczenia. Jak zwracaemna to uwagw poprzednim rozdziale, dziedziczenie jest jednz podstawowych cech

programowania obiektowego. Mechanizm ten umoliwia rozszerzanie moliwoci

wczeniej utworzonych klas bez koniecznoci ich ponownego tworzenia. Zasadadziedziczenia w Javie ma za podstawzaoenie, e wszystkie klasy dostpne w tymjzyku bazujw sposb poredni lub bezporedni na klasie gwnej o nazwie Object.Wszystkie klasy pochodzce od tej oraz kadej innej snazywane, w stosunku do tej,

po ktrej dziedzicz, podklasami. Klasa, po ktrej dziedziczy wasnoci dana klasa,jest w stosunku do niej nazywana nadklas. Jeli nie deklarujemy w aden sposbnadklasy, tak jak jest to pokazane w przykadowej deklaracji klasy Point, oznacza to,e stosujemy domylne dziedziczenie po klasie Object. Formalnie deklaracja klasyPointmogaby miepostazaprezentowanna listingu 2.18.

Listing 2.18.Dziedziczenie po klasie gwnej

class Point extends Object { // ... // ciao klasy Point // ...}

Wytuszczony fragment listingu 2.18 deklaruje dziedziczenie po klasie Object. Jakwczeniej pisaem, jest ono opcjonalne, to znaczy, e jeli go nie zastosujemy, Pointrwniebdzie domylnie dziedziczypo Object.

Przedstawiony sposb jest uywany w przypadku dziedziczenia po innych klasach,

tak jak na listingu 2.19.

Listing 2.19.Praktyczne uycie dziedziczenia

class Figura extends Point { ...}

class Wielokat extends Figura { ...}


17/89


W przykadzie tym klasa Wielokatdziedziczy po klasie Figura, ktra z kolei dziedzi-czy po Point, a ta po Object. W Javie nie ma adnych ograniczeco do zagniedania

poziomw dziedziczenia. Poprawne wic bdzie dziedziczenie na stu i wicej pozio-mach. Jakkolwiek takie gbokie dziedziczenie jest bardzo atrakcyjne w teorii, w praktyce

wie siz niepotrzebnym obcianiem zarwno pamici, jak i procesora. To samozadanie zrealizowane za pomocpytszej struktury dziedziczenia bdzie dziaao szybciejaz trzech powodw:

Wywoanie metod bdzie wymagao mniejszej liczby poszukiwaich istnieniaw ramach kolejnych nadklas.

Interpreter bdzie musiazaadowamniej plikw z definicjami klas(i mniej bdzie ich pniej obsugiwa).

System operacyjny (a przez to rwnieinterpreter Javy) ma wicej wolnejpamici, a przez to pracuje szybciej.

Ponadto w przypadku apletw moemy liczyna szybsze adowanie sistrony doprzegldarki, a wic bdzie to kolejna pozytywna strona.

Poza dziedziczeniem w dowolnie dugim acuchu od klasy gwnej do najniszej klasypotomnej w niektrych jzykach programowania (na przykad C++) istnieje wielo-krotne dziedziczenie jednoczenie i rwnorzdnie po kilku klasach. W Javie jest toniemoliwe, to znaczy w definicji kadej klasy moe wystpico najwyej jedno sowoextends. Zamiast wielokrotnego dziedziczenia w Javie dostpny jest mechanizm in-terfejsw opisany w podrozdziale 2.4. Interfejsy.

2.1.10. Inicjator klasy i obiektu

Wrmy do rozwaana temat tego, co sidzieje w pocztkach ycia obiektu. Pozakonstruktorem Java udostpnia dwa inne mechanizmy wspomagajce inicjacji two-rzenie zarwno klas, jak i obiektw. Inicjator klasy jest to blok instrukcji wykonywany

tylko raz, po zaadowaniu przez JVM pliku z klasprzed pierwszym uyciem (jednakklasa musi byuyta, eby blok ten wykonasi sama deklaracja uycia bez ini-cjacji nie gwarantuje wykonania inicjatora klasy). Blok ten, zawarty midzy dwomanawiasami klamrowymi, musi bypoprzedzony sowem kluczowym static(dokad-ne znaczenie tego modyfikatora zostanie wyjanione dalej w tym rozdziale). Poza tym

klasa moe zawierarwnie inicjator obiektu, czyli egzemplarza klasy. Jest to teblok instrukcji zamknity w nawiasach klamrowych, ale bez adnego kwalifikatora.Zarwno inicjator klasy, jak i obiektu moe wystpiw kadej klasie kilkukrotnie. Jeli

jest ich wiksza ilo, zostanwykonane zgodnie z kolejnocipojawienia siw ko-dzie rdowym. Poniej przedstawiony jest listing 2.20 z apletem, ktry zawiera rneelementy inicjacyjne wraz z instrukcjami umoliwiajcymi sprawdzenie kolejnociich wykonywania si(szczegy dziaania apletw zostanwprowadzone w rozdziale 3.Aplet jako obiekt na stronie HTML). W komentarzach zaznaczono priorytet wano-ci od 1 (najwaniejsze, wykonywane najpierw) do 3 (najmniej wane, wykonywanena kocu). Elementy inicjacyjne o tym samym priorytecie wykonywane szgodniez kolejnociwystpienia. Warto zauway, e inicjator obiektu i inicjator pl obiektu

majten sam priorytet i wykonywane szgodnie z kolejnociwystpienia w klasie.


18/89


19/89


wspolnyInit(); // przetwarzanie s } void wspolnyInit() { /*inicjacja*/ } }

}

Dziaanie takie jest poprawne, ale wymaga od nas pamitania o dodaniu jednego wy-woania metody w kadym kolejnym konstruktorze oraz zwiksza wielkokodu wy-nikowego. Kady konstruktor zawiera bowiem wywoanie tej metody. Zastosowanieinicjatora obiektu uwalnia nas od koniecznoci kadorazowego dodawania tego wy-woania oraz usuwa ten fragment kodu z konstruktora. Biorc pod uwagto, e aplet

jest programem adowanym do komputera uytkownika przez internet (czasami, gdykorzysta siz dowolnej linii telefonicznej), kade kilkadziesit czy kilkaset bajtwmoe bywane (ten sam problem dotyczy telefonw komrkowych, ktre snajcz-

ciej wyposaone w bardzo mapami). Jeli tylko jest to moliwe, wsplny kodinicjacyjny powinno umieszczasiw bloku inicjacyjnym. Dla klasy z listingu 2.21rozwizanie takie miaoby postazaprezentowanna listingu 2.22.

Listing 2.22.Kod inicjacyjny we wsplnym bloku

class MultiKonstruktor { public MultiKonstruktor(int i) { // przetwarzanie i } public MultiKonstruktor(String s) { // przetwarzanie s }

{ /* tu wsplna inicjacja */}}

Warto zauway, e zaoszczdzilimy nie tylko na dwch wywoaniach metody, alemoglimy zrezygnowanawet z bezparametrowego konstruktora, ktrego jedynprac

byo uruchomienie procedury wsplnej inicjacji. Tak wic argumentem na stosowanietakiego rozwizania jest nie tylko dbanie o uytkownikw wdzwaniajcych sido in-ternetu, ale rwnieelegancja i prostota, ktre prawie zawsze skutkujzmniejszeniemliczby popenianych bdw.

Warto zwrciuwagna to, e (inaczej niw przypadku apletw) w przypadku pro-gramw, ktre mogegzystowa samodzielnie, przed jakkolwiek inicjacj obiektu

przeprowadzana jest inicjacja statyczna, a nastpnie wykonywana jest metoda main i todopiero w niej moe bytworzony egzemplarz obiektu. Dzieje sitak, gdymetoda ta

jest statyczna i publiczna i moe byuyta przed stworzeniem egzemplarza obiektu(dokadniejsze wyjanienia co do natury metod statycznych zostanzamieszczone dalejw tym rozdziale). Maszyna wirtualna Javy jest tak skonstruowana, e wywouje tmetodjako pierwsz. W przypadku samodzielnych programw naley wic wzi

pod uwagten aspekt i zmodyfikowakolejnowywoywania blokw inicjacyjnych.


20/89


2.1.11. Kolejno inicjacji klas

Powrmy do kwestii kolejnoci, w jakiej wykonuje siinicjacja klas. Zamy, e naszedziedziczce klasy bdskonstruowane wedug schematu pokazanego na listingu 2.23.

Listing 2.23.Bloki inicjujce w klasach dziedziczcych

class A { A() { System.err.println("konstruktor A"); } { System.err.println("inicjator obiektu A"); } static { System.err.println("inicjator klasy A"); }}

class B extends A { B() {System.err.println("konstruktor B"); } { System.err.println("inicjator obiektu B"); } static { System.err.println("inicjator klasy B"); }

}

Pierwsze uycie pokazanej na listingu 2.23 klasy B, przy zaoeniu, e wczeniej nieuywalimy klasy A, spowoduje wywietlenie kolejnych napisw, ktre pokazane sna rysunku 2.2.

Rysunek 2.2.Wydruk generowany

przez programz listingu 2.23

inicjator klasy Ainicjator klasy Binicjator obiektu A

konstruktor A

inicjator obiektu B

konstruktor B

Jak wic wida, najpierw w kolejnoci dziedziczenia inicjowane sklasy. Ponich nastpuje sekwencja charakterystyczna dla inicjacji obiektw typu klasy nad-rzdnej. Obiekty te nazywam egzemplarzami wirtualnymi. W praktyce JVM rezerwujeod razu pamina cay rzeczywisty obiekt, jednak tworzenie go jest przeprowadzanesekwencyjnie. Najpierw inicjowany jest wirtualny obiekt bazowy, pniej uzupe-niane sbraki przez inicjacje kolejnych klas pochodnych. Inicjacja obiektw wirtual-nych, zaznaczona na rysunku 2.2 kursyw, jest blokiem nie do rozczenia. Jeli klasauywajca Bma blok inicjujcy klas, to zostanie on wykonany przed inicjatorem kla-sy A. Sytuacja nie zmieni si, jeli w pierwszej linii konstruktora klasy Bdodamy jawnewywoanie konstruktora klasy nadrzdnej (z uyciem sowa super), czyli klasy A, tak

jak pokazaem to na listingu 2.24. Odwoanie do klasy nadrzdnej dokadnie zostaniewyjanione w paragrafie 2.1.14. Odwoanie do klas nadrzdnych.

Listing 2.24.Rozszerzenie inicjacji klas z listingu 2.23

class B extends A { B() { super(); System.err.println("konstruktor B"); } { System.err.println("inicjator obiektu B"); } static { System.err.println("inicjator klasy B"); }

}


21/89


Zgodnie z tym, co wczeniej napisaem, konstruktor klasy nadrzdnej wywoywanyjest domylnie jako pierwsze dziaanie konstruktora danej klasy.

Z sekwencyjnym tworzeniem i inicjacjobiektw dziedziczcych zwizany jest pe-

wien wany problem. Pokago na przykadzie klasy nadrzdnej o postaci zaprezen-towanej na listingu 2.25.

Listing 2.25.Klasa, po ktrej trudno dziedziczy

public class A { private Object o; public A(Object o) { this.o = o; }}

Klasa taka nie umoliwia utworzenia dziedziczenia w postaci zaprezentowanej na li-stingu 2.26.

Listing 2.26.Bdne dziedziczenie po klasie z listingu 2.25

public class B extends A { Object oo = new Object(); public B() { super(oo); // bd }}

W takim przypadku konstruktor klasy nadrzdnej, reprezentowany przez linisuper(oo),jest wywoywany, zanim utworzony zostanie egzemplarz ooklasy Object. Przed kon-struktorem klasy nadrzdnej nie moe bowiem bywykonywana adna inna akcja po-za ewentualnym wywoaniem innego konstruktora przecionego, ktry wywoa kon-struktor super. Podobnie niepoprawna bdzie tekonstrukcja pokazana na listingu 2.27.

Listing 2.27.Bdne dziedziczenie po klasie z listingu 2.25

public class B extends A { public B() { super(this); // bd }

}

Bd wynika z tego, e egzemplarz obiektu tej klasy, reprezentowany przez this, bdzieznany dopiero po jego utworzeniu, a wic najwczeniej po zakoczeniu pracy kon-struktora klasy nadrzdnej.

Mimo takiego podejcia, to znaczy kolejnego tworzenia egzemplarzy obiektw klasdziedziczcych, metody tych klas sformalnie dostpne w obiektach nawet przed ichutworzeniem. Moe to spowodowa powstanie bdnego, przynajmniej w naszym

pojciu, dziaania niektrych konstruktorw. Na listingu 2.28 zaprezentowane zostaydwie klasy Ai B. W klasach tych metoda doSthzostaa zadeklarowana i wykorzy-stana niepoprawnie.


22/89


Listing 2.28.Bdne deklaracje metody w klasach dziedziczcych

class A { A() { doSth();

} void doSth() { System.err.println("A.doSth"); }}

class B extends A { B(){ super(); doSth(); } void doSth() { System.err.println("B.doSth");

}}

Jeli zadeklarujemy uycie klasy Bi utworzenie z niej obiektu

B b = new B();

otrzymamy niespodziewany dla wikszoci osb wynik (wydruk na konsoli Javy):

B.doSthB.doSth

Zaobserwowany efekt dziaania jest jednak poprawny. Jest on skutkiem dziaania po-limorfizmu. W zaprezentowanym przykadzie konstruktor w klasie Awywouje metoddoSthtworzonego obiektu (czyli klasy B). Tak wic to metodtej klasy wywoa kon-struktor klasy A, mimo itwrca miazapewne co innego na myli. Aby wywoaniedoSth zawsze dotyczyo wasnej klasy, metoda ta musi byprywatna (modyfikatorprivate). Warto na to zwrciuwag, gdymoe to byprzyczynwielu podobnychnieporozumie. Inicjacja klasy:

B b = new B(3);

ktrej definicja pokazana jest na listingu 2.29, moe przynienieoczekiwany efekt.

Listing 2.29.Uycie metod w konstruktorze

public class A { public A() { System.out.println("wewntrz konstruktora A"); doSth(); } public void doSth() { System.out.println("nic nie robi"); }}

public class B extends A { private int p1; public B(int p) {


23/89


p1 = p; System.out.println("wewntrz konstruktora B"); } public void doSth() { System.out.println("p1=" + p1);

// obliczenia z uyciem p1 }}

Pozornie nieoczekiwany wynik dziaania klasy z listingu 2.29 zaprezentowaem narysunku 2.3.

Rysunek 2.3.

Wydruk generowany

przez program 2.29

wewntrz konstruktora Ap1=0wewntrz konstruktora B

Czyli tak jak napisaem wczeniej, przed uruchomieniem konstruktora klasy B(czyliprzed powstaniem egzemplarza tej klasy) system potrafi juuyjego metody doSth.Oczywicie skoro dzieje sito przed uruchomieniem konstruktora B, prywatne pole p1nie jest jeszcze zainicjowane, wic jest rwne zero. Wicej na temat polimorfizmuznajdziesz w paragrafie 2.2.6. Efekty polimorfizmu.

2.1.12. Destruktor

Podchodzc formalnie do specyfikacji JVM, mona powiedzie, e klasy Javy niewymagajstosowania specjalizowanych metod zwalniajcych zajtprzez siebie pa-

mi. Wynika to z zaoenia przyjtego w czasie tworzenia tego systemu, a mianowi-cie braku jawnego zwalniania pamici zajmowanej przez obiekty. Podejcie klasycznestosowane w C++ i Object Pascalu zakada, e to programista, w chwili kiedy uznajeto za stosowne lub gdy wymusza to struktura programu, zwalnia pami, korzystajcz jawnych funkcji systemowych bdspecjalizowanych metod wbudowanych w obiekty(destruktory). Podejcie takie ma t zalet, e umoliwia zwalnianie pamici na-tychmiast, kiedy jest to moliwe. Ma jednak t wad, e moe powodowa prbyodwoania si do obiektu omykowo i przedwczenie zwolnionego. W Javie zrezy-gnowano wic z tego mechanizmu. Nie oznacza to jednak braku metody, ktra byabynamiastkdestruktora. Jest nimetoda finalizewywoywana w trakcie czyszczenia

pamici. Ma ona za zadanie wykonawszystkie konieczne dziaania przed cakowitymzastopowaniem oraz zwolnieniem pamici przez obiekt, do ktrego naley (jednakzwalnianie pamici nie naley judo obowizkw tej metody). Typowa deklaracjafunkcji koczcej dziaanie obiektu powinna miepostapokazanna listingu 2.30.

Listing 2.30.Przykadowa deklaracja destruktora

public void finalize() { zatrzymajWatki(); usunPowiazania();}


24/89


25/89


2.1.14. Odwoanie do klas nadrzdnych

Nie zawsze jednak przykrywanie metod jest podanym efektem. Mog zaj sytu-acje, w ktrych mimo tego e mamy przykryte pewne metody, chcielibymy odwoasido nich, gdywiemy, e wykonujprzydatne dla nas dziaanie. Dokonuje sitego

poprzez referencjsuper(jest to to samo sowo kluczowe, ktrego uywa sido wy-woania konstruktora klasy nadrzdnej). Na listingu 2.32 przedstawiona jest zmodyfi-kowana klasa C, ktra pokae, jak odwoa sido metody swojej klasy nadrzdnej,mimo e metoda ta jest przykryta.

Listing 2.32.Sposb odwoania do metody klasy nadrzdnej

class C extends B { public void show() { info(); super.info(p;

// super.super.info();


26/89


W tym przykadzie konstruktor klasy Testwykonuje dokadnie to samo, co konstruktorjego klasy nadrzdnej, oraz dodatkowo wywietla cig tekstowy przekazywany w pa-rametrze b. Naley pamita, e odwoanie do konstruktora klasy nadrzdnej, jeliwystpuje, musi bypierwszinstrukcjw konstruktorze. Jedynym wyjtkiem jest od-

woanie do innego konstruktora w tej samej klasie z uyciem sowa this. Jeli chcemyjawnie wywoakonstruktor nadklasy, wtedy ten drugi konstruktor, do ktrego odno-simy siprzez this, musi juuyodwoania superw pierwszym wierszu metody.

2.1.15. Odwoanie do pl klas nadrzdnych

Pewnnamiastkodwoania do klas nadrzdnych na dowolngbokoacucha dzie-dziczenia jest odwoanie do pl pokrywanych w kolejnych podklasach, co postaramsipokazana listingu 2.33.

Listing 2.33.Klasa dziedzicz

ca cechy bez modyfikacji

class A { String info = "klasa A";}

class B extends A { }

Formalnie, jeli pole nie jest prywatne, konstrukcja zaprezentowana na listingu 2.33oznacza, e klasa Bposiada pole o nazwie infotypu Stringzawierajce tekst "klasa A".

Nie stosuje siwic ponownego definiowania tego pola, nawet jeli chcemy je wyko-rzystaw inny sposb, nipierwotnie zakadalimy w klasie A. Moemy jednak za-

stosowapokrycie pl w klasie, tak jak pokazano to na listingu 2.34.

Listing 2.34.Pokrywanie pl w klasie dziedziczcej

class A { String info = "klasa A";}

class B extends A { String info = "klasa B";}

class C extends B {

String info = "klasa C"; public void show() { System.err.println(((A)this).info); }}

Jeli wywoamy metodshowobiektu klasy Cna konsoli Javy, zobaczymy napis:

klasa A

Takie zachowanie, rnice siod zachowania metod, wynika z faktu, e odwoywaniesido metod zaley od faktycznego typu obiektu, ktrego w danym momencie uy-

wamy. Natomiast w stosunku do pl uywany jest zadeklarowany typ obiektu. Jest to


27/89


28/89


klaszawierajcprzynajmniej jednpust deklaracjoraz wszystkie metody, ktres wycznie deklarowane. Przykad klasy abstrakcyjnej pokazany jest na listingu2.36. Fakt, e klasa jest abstrakcyjna,, wynika z braku implementacji metody getInfo.

Listing 2.36.Przykadowa klasa abstrakcyjna

abstract class Obliczenia { abstract public String getInfo(); public void doMath() { // ciao metody }}

W przypadku prby dziedziczenia po takiej abstrakcyjnej klasie wszystkie metody

abstrakcyjne muszzostapokryte. W przeciwnym wypadku klasa dziedziczca rwniebdzie abstrakcyjna. Klasa abstrakcyjna nie moe posuy jako wzorzec do utwo-

rzenia egzemplarza klasy. Tak wic zastosowanie klasy abstrakcyjnej to sposb nawymuszenie implementacji pewnych metod w programie uywajcym naszych klas.Poza klasami abstrakcyjnymi podobnym mechanizmem s interfejsy, ktre zostanopisane dalej w tym rozdziale. Przeprowadztam krtkie porwnanie klas abstrakcyj-nych i interfejsw oraz przypadkw wskazanych do ich zastosowania. Jedynz zalet nie-dostpnych w interfejsach, ktrma mechanizm klas abstrakcyjnych, jest moliwouczynienia abstrakcyjnymi niektrych klas majcych wczeniej penoprawn funk-cjonalno. Mona tego dokona, pokrywajc w klasie pochodnej jedn lub wicejmetod metodami abstrakcyjnymi, czyli bez implementacji. Dziki temu moemyusun standardow implementacj metod, wymuszajc ich przysz, waciwsz

dla danej klasy implementacj.

2.2. Obiekty

Jak kilkukrotnie zwracaem juuwag, klasy stylko definicji okreleniem sposobudziaania bd przechowywania informacji. Aby klasa moga by uyta, musimyutworzyjej egzemplarz, ktrym jest obiekt. Istniejdwa podstawowe sposoby two-rzenia obiektw zdefiniowanych typw tak aby byy jawnie dostpne oraz w sposbniejawny. Poniej przedstawirnice midzy nimi. Ponadto sprbujzwrciuwagnawszystkie wane zagadnienia zwizane z tworzeniem i egzystowaniem obiektw w Javie.W dalszej czci tego rozdziau pokarwniesposb tworzenia obiektw z uyciemrefleksji (typy tych obiektw nie muszbyznane w czasie tworzenia programu).

2.2.1. Rozwaania o adresie

Przed przystpieniem do praktycznych przykadw tworzenia obiektw powiniene,zwaszcza jeli znasz inne jzyki programowania, dowiedziesi, co wie siz po-wstaniem pojedynczego egzemplarza klasy. W C++ czy Object Pascalu utworzenie

egzemplarza zmiennej typu obiektowego wizao si z przydzieleniem jej pewnego


29/89


obszaru pamici (jawnie bdnie, rcznie bdautomatycznie). Zmienna typu obiekto-wego przechowywaa wycznie wskazanie na obszar, w ktrym znajdowa siobiekt,

bdna miejsce, gdzie znajdowa siopis obiektu i dalsze adresy pl oraz metod.W Javie, wbrew obiegowym opiniom, jest dokadnie tak samo. Zmienna reprezen-

tujca obiekt to rzeczywicie wskazanie (albo wedug innego nazewnictwa adres) nablok rozpoznawany przez maszynwirtualnJavy jako zbir wszystkich potrzebnychinformacji do jednoznacznego zidentyfikowania obiektu i poprawnego uywania go.

Na tym jednak koczy sipodobiestwo midzy wskazaniem na obiekt w Javie a w in-nych jzykach. W Javie nie da si wykonakilku podstawowych operacji dostp-nych w C++ czy Object Pascalu. Nie da siutworzysamoistnego obszaru pamicii wymusipotraktowanie go przez kompilator bdinterpreter jako obiekt. Nie da sidodado wskanika liczby bdcej wielokrotnocidugoci sowa maszynowego,aby odwoasibezporednio do pola, metody bdnastpnego obiektu w pamici.

Najwicej trudnoci sprawia natomiast przyzwyczajenie sido tego, e obiekt, ktrynie jest juprzez nas uywany, nie moe byzwolniony na nasze danie, tylko mu-simy zdasiprzy tym na askJVM. Jednak te trzy ograniczenia sprawiaj, e Java

jest jzykiem, ktry wynosi bezpieczestwo kilka krokw naprzd, przed inne jzyki.Dostajemy zalety pracy na wskanikach i pozbawieni jestemy moliwoci wiado-mego (bdnie) zniszczenia sobie dziaajcego programu. W dalszej czci ksiki

bduywazamiennie nazwy obiekt, egzemplarz, adres bdwskazanie. Nie powinnoCito jednak zwie. Bdcay czas mwio tym samym o symbolicznej repre-zentacji pojedynczego egzemplarza klasy.

Zanim przejdziemy do praktycznego stosowania obiektw, chciabym przypomnie,e w Javie udostpniony jest mechanizm kompatybilnoci typw obiektowych wyni-

kajcych z dziedziczenia klas. To znaczy mo

emy zadeklarowa

obiekt jako egzem-plarz klasy dokadnie tego samego typu, jaki tworzymy, albo jako egzemplarz dowol-

nej klasy nadrzdnej tego obiektu, czyli takiej, ktra znajdowaa siw acuchu jegodziedziczenia. W skrajnym przypadku moemy wic deklarowaw Javie wszystkieobiekty jako egzemplarze klasy Object, po ktrej dziedziczwszystkie klasy w Javie.Takie podejcie, jakkolwiek formalnie suszne i niezmniejszajce (dziki mechanizmowi

polimorfizmu) funkcjonalnoci programu, w praktyce jest bardzo uciliwe. Wymagabowiem od programisty cigego umieszczania referencji typu obiektu w momencieodwoywania sido pl czy metod istniejcych wycznie w klasach pochodnych.Interpreter zna cile typ obiektu w czasie uruchomienia programu, ale kompilatorw czasie kompilacji nie jest tego w stanie stwierdzi. Tak wic prociej jest uywa

zmiennych waciwego typu. Moliwostosowania typu nadrzdnego powinno po-zostawisiwycznie do sytuacji wyjtkowych, kiedy jest to wytumaczone potrzebuproszczenia bdzwikszenia funkcjonalnoci projektu.

2.2.2. Jawne uycie obiektw

Rozpoczcie tworzenia obiektu naley zaczod deklaracji uycia egzemplarza kon-kretnego typu. Poza typem i modyfikatorem musi ona zawieraunikalnnazw, ktraumoliwi przyszidentyfikacjobiektu. Przykad takiej deklaracji podany jest poniej:

Button b;


30/89


W przykadzie tym pod nazwbbdzie siw przyszoci ukrywaobiekt klasy Button(nalecy do standardowej biblioteki AWT). Bdzie, poniewabezporednio po de-klaracji zmienna b nie reprezentuje jeszcze adnego konkretnego wskazania. Samadeklaracja powoduje przypisanie zmiennej wartoci null. To znaczy kompilator wie

ju, e zmienna bjest odpowiedniego typu i moemy z jej pomocodwoasido pli metod klasy Button, jednak brak nam jeszcze samego obiektu. Dopiero konstrukcja:

b = new Button();

fizycznie tworzy jej pojedynczy egzemplarz. W praktyce operator newrezerwuje pa-mipotrzebndla danego obiektu, inicjuje waciwe pola w tym egzemplarzu orazzwraca do zmiennej badres zarezerwowanego bloku pamici. Warto wiedzie, e wiel-koi sposb rezerwacji pamici nie zaley od typu zmiennej zadeklarowanej wcze-niej, lecz od konstruktora. To on, a nie deklaracja zmiennej, determinuje wynik two-rzenia egzemplarza. Ponadto powinno si te pamita o tym, e wywoanie newskojarzone jest rwnieze sprawdzeniem, czy wskazana klasa bya wczeniej uywanai czy jest zaadowana do pamici. Jeli nie, jest ona znajdowana na dysku bdw siecii adowana do pamici. Po zaadowaniu, jeli w klasie wystpuje jej inicjator, uru-chamiany jest jego kod. Dopiero po tym procesie nastpuje przejcie do faktycznejrealizacji zadaskojarzonych z operatorem new.

Poza konstrukcjpokazanpowyej, czyli osobno deklarujemy zmienntypu obiek-towego i osobno tworzymy egzemplarz klasy, moemy te operacje wykonaw sposbspjny, umieszczajc je w jednym wierszu programu:

Button b = new Button();

Z konwencji takiej korzysta sinajczciej wtedy, gdy zmienna obiektowa uywanajest wycznie w obrbie jednej metody bdobiekt moe byutworzony globalniei deklaracja zmiennej znajduje si poza ciaem jakiejkolwiek metody. Jeli jednakobiekt ma bydostpny w caej klasie, lecz jego inicjacja uzaleniona jest od innych do-datkowych czynnikw bdczynnoci, naley zastosowarozczndeklaracji tworzenieobiektu. Najczciej obiekt tworzy siwtedy w konstruktorze, tak jak na listingu 2.37.

Listing 2.37.Rozczne deklarowanie i tworzenie obiektu

class DemoPanel extends Panel { Button b; public DemoPanel() { b = new Button(); b.setLabel("przycisk");

}}

Moment tworzenia obiektw jest dobry, aby przypomnieo kwestii przecienia kon-struktorw. Stosowany w tym paragrafie jutrzy razy przykad bazowana wykorzy-staniu bezparametrowego konstruktora, ktry tworzy przycisk ekranowy bez adnegonapisu. Dodanie napisu na tym przycisku wymaga uycia metody setLabel, co poka-zano na ostatnim przykadzie. Obie operacje mona poczy, korzystajc z innegokonstruktora, ktry tworzy od razu przycisk z opisem:

b = new Button("przycisk");

Jak wida, jest to prostsze rozwizanie, co wcale nie oznacza, e trzeba je zawsze stosowa.


31/89


32/89


Listing 2.38.Definicja klasy, ktrej obiekty mogbypowielane

class A implements Cloneable { int i1, i2; public Object clone() {

try { return super.clone(); } catch(Exception e) { return null; } }}

Jej uycie przedstawione jest na listingu 2.39.

Listing 2.39.Powielanie obiektw z listingu 2.38

public class Applet2 extends Applet { A a1 = new A(); A a2; public void init() { a1.i1 = 1; a1.i2 = 2; a2 = (A)a1.clone(); a2.i1 = 3; a2.i2 = 4; System.err.println(a1.i1); System.err.println(a1.i2); }}

Dla upewnienia si, e powstay dwa rne obiekty, zastosowaem tu zmianwartocipl jednego z nich i sprawdzenie, czy pola drugiego nie zmieniy si. W wynikudziaania tego programu na konsoli przegldarki zobaczymy liczby 1i 2. Oznacza to,e rzeczywicie mamy do czynienia z dwoma rnymi egzemplarzami. Gdyby za-miast uycia metody klonujcej zastosowaproste podstawienie obiektw, o ktrym

juwczeniej pisaem, e jest niepoprawne:

a2 = a1;

na konsoli zobaczylibymy liczby 3i 4. Oznaczaoby to, e mamy co prawda dwie re-ferencje do obiektw, ale obie do jednego egzemplarza. To znaczy nie mamy dwch

kopii obiektu, ale dwa wskazania na jeden obiekt.

2.2.4. Niejawne uywanie obiektw

Rezerwowanie dla obiektu nazwy symbolicznej ma sens jedynie wtedy, gdy w dalszej

czci programu zamierzamy go wykorzystywa. S jednak sytuacje, kiedy obiekttworzony jest doranie wycznie na potrzeby jednorazowej akcji i nie zamierzamysijudo niego nigdy odwoywa. Tak na przykad moe byw przypadku etykietumieszczanych w programie w celach informacyjnych. Raz umieszczon etykiet

zamierzamy pozostawiw tym miejscu, gdzie jumiecilimy, bez adnych zmian.


33/89


Nie interesuje nas odwoanie do niej (chociaw praktyce wyglda to tak, e systembdzie to robiza nas w sposb niejawny). W takim przypadku moemy skorzystaz niejawnej metody tworzenia obiektw pokazanej na listingu 2.40.

Listing 2.40.Inicjacja etykiety bez nadania nazwy jej zmiennej

class DemoPanel extends Panel { public DemoPanel() { this.add(new Label("napis informacyjny"p, nullp; }}

W pokazanym przykadzie obiekt tworzony jest wycznie po to, aby mona go byouyw metodzie add, ktra dodaje napis informacyjny do naszego panelu. Korzystamytu z wiedzy o sposobie wywoywania metod w Javie. Otparametry przekazywanedo tych metod swyliczane przed ich wywoaniem. W zwizku z tym przedstawionakonstrukcja powoduje, e przed przekazaniem w postaci parametru uruchamiany jestkonstruktor nowego obiektu klasy Label, ktrego adres przekazywany jest jako para-metr. Oczywicie niejawne uycie nie oznacza wcale, e obiekt istnieje tylko przezczas wykonywania metody add. Wewntrz tej metody obiekt przypisywany jest do

pojedynczego elementu nowej zmiennej tablicowej typu umoliwiajcego przecho-wywanie takich obiektw. W zwizku z tym, korzystajc ze spostrzeenia poczynio-nego wczeniej, wytuszczona linia mogaby byrozwinita bez zmiany funkcjonal-noci do postaci:

Label l = new Label("napis informacyjny");this.add(l, null);

l = null;

W zwizku z niepotrzebnrozwlekocikodu i niecelowym zablokowaniem nazwyzmiennej na potrzeby jednorazowej akcji naturalne jest uycie niejawnej formy utwo-rzenia obiektu, ktra nie wymaga rezerwacji nazwy zmiennej.

2.2.5. Typ zmiennej i obiektu. Operator instanceof

W dotychczasowych przykadach uywania obiektw typ zmiennej, ktry suydoich przechowywania, bydokadnie taki, jak ich typ. Takie rozwizanie jest jak naj-

bardziej suszne i najczciej uywane. Nie oznacza to jednak, e jest to jedyny spo-sb na deklarowanie zmiennych obiektowych. Czsto zdarza si, e w celu zwikszeniafunkcjonalnoci programu deklarujemy zmienninnego typu, niw efekcie bdziemywykorzystywa. W bezpieczny sposb moemy deklarowa typ zmiennej jako typnadklasy klasy, ktrej bdziemy uywali. Moemy wic zadeklarowa, a nastpnie utwo-rzyzmiennz uyciem konstrukcji:

Object b;b = new Button("przycisk");

Taka konstrukcja nazywa sibezpiecznkonwersjtypu, konwersjw gr lub roz-

szerzaniem zakresu zmiennej. Dalsze uycie zmiennej bmoe okazasiutrudnione, gdy


34/89


bdziemy chcieli wykorzystacechy obiektu charakterystyczne nie dla typu zmiennej,a dla rzeczywistego typu obiektu. Bez problemw moglibymy uydla tej zmiennejmetody toStringzadeklarowanej w klasie Object, ktra zwraca tekstowreprezenta-cjtego obiektu. Jednak wstawienie obiektu typu przycisk ekranowy (Button) do gra-

ficznego obrazu programu wymaga uycia funkcji add, ktra oczekuje, e parametr jejwywoania bdzie obiektem typu Componentlub obiektem typu pochodnym. W zwizkuz tym, e Objectjest klasnadrzdndla Component, uycie zmiennej typu Objectniezostanie zaakceptowane:

add(b, null); // jeli b typu Object, to bd

Jeli mamy pewno, e bjest typu Button(lub Component, po ktrym dziedziczy Button),wtedy moemy uyjawnej konwersji typu Objectna typ akceptowany przez metodadd:

add((Component)b, null);

Takie wywoanie zostanie zaakceptowane przez kompilator. W wywoaniu tym zasto-sowalimy niebezpiecznkonwersjtypu, konwersjw dbdzwenie typu zmiennej.Jeli konwersja jest poprawna, to znaczy zmienna breprezentuje obiekt typu Componentlub pochodny od niego, wtedy wszystko zadziaa dobrze. Gdyby jednak okazao si,e bnie przechowuje obiektu typu Componentani adnego innego od niego pochodz-cego, wtedy wystpi bd (konkretnie bdzie to wyjtek ClassCastException), ktrywstrzyma wykonanie programu wykonanie. Gdyby konwersja bya niepoprawna juna etapie kompilacji, to znaczy prbowalibymy konwertowatyp obiektw midzydwoma gaziami dziedziczenia, wtedy bd wystpiby juna etapie kompilacji.

Zdarza si, e aby podnieuniwersalnoniektrych fragmentw programu, z zao-

enia stosuje siklasnadrzdnjako typ zmiennej. Czsto, niemal nagminnie, sto-suje si takie rozwizanie w przypadku przekazywania obiektw poprzez parametrydo wntrza metod. Nie mamy wtedy adnej pewnoci, jakiego typu obiekt odbieramy.Do obsugi takich sytuacji Java posiada operator instanceof, ktry umoliwia zbada-nie typu egzemplarza klasy. W praktyce dokonuje on porwnania typu egzemplarza

klasy z typem klasy. Przykad jego uycia pokazany jest na listingu 2.41.

Listing 2.41.Przykadowe badanie typu obiektu

public void UseObject(Object comp) { if (comp instanceof Button) { // obsuga obiektu typu Button

} else if (comp instanceof Label) { // obsuga obiektu typu Label } else { // obsuga innych obiektw }}

Takie podejcie zapewnia zabezpieczenie programu przed nieoczekiwanymi prze-rwami w pracy oraz umoliwia wprowadzenie do niego wikszej funkcjonalnoci.


35/89


2.2.6. Efekty polimorfizmu

Polimorfizm to zamierzone dziaanie w idei programowania obiektowego. Zapewniaono wielopostaciowodziaania zalenod wykorzystywanego obiektu. Dokadnieopisaem to w poprzednim rozdziale. Ponadto wspominaem juo tym zarwno przyopisywaniu dziedziczenia, jak i przykrywania pl i metod. Ominwic rozwaaniateoretyczne, a przedstawi tylko efekt dziaania polimorfizmu. Do prezentacji wyko-rzystam dwie klasy o definicji podanej na listingu 2.42.

Listing 2.42.Klasy dziedziczce z pokrytymi metodami

class A { public void info1() { System.err.println("klasa A(1)"); } public void info2() {

System.err.println("klasa A(2)"); info3(); } public void info3() { System.err.println("klasa A(3)"); }}

class B extends A { public void info1() { System.err.println("klasa B(1)"); } public void info3() { System.err.println("klasa B(3)"); }}

Efekty dziaania polimorfizmu bd mg zaobserwowa dziki apletowi przedsta-wionemu na listingu 2.43.

Listing 2.43.Uycie klas z pokrytymi metodami

public class Applet2 extends Applet { public void init() {

A a = new A(); a.info1(); a.info2(); a = new B(); // a staje siklasy B a.info1(); a.info2(); }}

Na konsoli Javy przegldarki internetowej pojawi si cig napisw zaprezentowanyna rysunku 2.5.


36/89


Rysunek 2.5.

Wydruk generowany

przez listing 2.43z uyciem klas

z listingu 2.42

klasa A(1)klasa A(2)klasa A(3)klasa B(1)klasa A(2)

klasa B(3)

Naley zwrciuwagna nastpujce sprawy:

Wywoywana jest metoda info1zawsze tej samej klasy, jakiego typujest obiekt w danym momencie przechowywany w zmiennej a. Dzieje sitak mimo tego, e typ zmiennej ato A. Tak wic odwoanie dotyczyrzeczywistego typu obiektu, a nie wymienionego w referencji.

Moemy wywoametodinfo2obiektu typu B, mimo e nie zostaa onaw nim zaimplementowana. Oznacza to, e metoda ta zostaa odziedziczona

po klasie Ai jest traktowana jak wasna metoda obiektu B. Jakkolwiek jej

wywoanie nie jest polimorficzne, w przypadku dalszego dziedziczeniai pokrycia jej moe powstaten efekt.

Metoda info3, jakkolwiek wywoywana z metody zaimplementowanej tylkow klasie A, rwniepochodzi z tej klasy, ktrej typ reprezentuje obiekt.Tak wic tworzc klasA, moemy przewidzieuycie nieistniejcej jeszczemetody z klasy pochodnej, ktra zostanie utworzona dopiero w przyszoci.

Przypominam, e inny przykad dziaania polimorfizmu pokazany zosta wczeniejw paragrafie 2.1.11. Kolejnoinicjacji klas. Problemy zwizane z polimorfizmemi klasami wewntrznymi omwione stew paragrafie 2.3.2. Polimorfizm i zmienne

klasy zawierajcej.

Omawiajc efekt polimorfizmu, warto tewspomnie, e niektrzy autorzy pod pojciepolimorfizmu podcigajmoliwoprzeciania metod. Wydaje mi sito zbyt roz-szerzon interpretacj. Metody przecione to zazwyczaj takie, ktre dziaajw bar-dzo podobny sposb, tylko przekazywanie do nich parametry sinnego rodzaju bdwykorzystuje sidomylne. Ponadto istnieje wiele jzykw programowania, ktre nieudostpniajprzecienia metod, i nikt nie zwraca uwagi na to, e ich polimorfizm

jest zuboony. Wedug mnie przecianie nie naley do zakresu polimorfizmu, alezwracam uwagna to, e moesz zetknsiz taktez.

2.3. Klasy wewntrzne i lokalne

W klasycznym podejciu kada klasa w Javie zawarta jest w osobnym pliku albo sta-nowi odrbny, atwy do wydzielenia fragment wikszego. Dziki temu klasy mogtworzybiblioteki dostpne z dowolnego miejsca w caym programie. Od reguy tejistniejpewne wyjtki wprowadzone w celu podniesienia stopnia hermetyzacji pro-gramu. Wyjtkami tymi sklasy wewntrzne i lokalne. Klasawewntrzna to zdefi-niowana w miejscu, w ktrym moe wystpidefinicja pola lub metody. Musi wic

ona wystpimidzy pierwszym i ostatnim nawiasem klamrowym ograniczajcym ciao


37/89


klasy na prawach rwnych polu lub metodzie. Klasa, w ktrej definiowana jest klasa

wewntrzna, nazywana jest zawierajc. Klasy lokalneto klasy zdefiniowane w blokuprogramu Javy. Ta kwestia moe wic dotyczy inicjatora klasy, inicjatora obiektu,konstruktora bd(najczciej) metody. Klasa lokalna moe odwoywasido wszystkich

zmiennych widocznych w miejscu wystpienia jej definicji. Jest ona widoczna i moezostauyta tylko w bloku, w ktrym zostaa zdefiniowana. Poza tymi cechami cha-rakterystycznymi klasy wewntrzne i lokalne snajzwyklejszymi klasami. Mona jetworzyprzy uyciu regu obowizujcych wobec zwykych klas. Gwne zalety tomoliwoukrywania nazw klas w strukturze bibliotek i pakietw Javy (poza szcze-glnymi sposobami uycia sone niedostpne z zewntrz) oraz uywania zmiennychlokalnych w tych klasach. Daje to czasami moliwo lepszej optymalizacji niekt-rych fragmentw kodu zarwno ze wzgldu na uatwienia w implementacji algoryt-mu, jak i pracy kompilatora. Ponadto udostpnia mechanizm zbliony do typu proce-duralnego, ktry jest dostpny w wikszoci obiektowych jzykw programowania.Przykad pokazujcy umiejscowienie klasy wewntrznej i lokalnej pokazany jest nalistingu 2.44.

Listing 2.44.Przykad klasy wewntrznej i lokalnej

class Zawierajaca { Wewnetrzna w = new Wewnetrzna(); class Wewnetrzna { // ciao klasy wewntrznej } public void metodaZ() { Lokalna l = new Lokalna(); class Lokalna {

// ciao klasy lokalnej

} // ciao metody MetodaZ }

// ciao klasy zawierajcej}

Mimo tego, e klasy te spenoprawne pod wzgldem konstrukcyjnym, sugeruje si,aby nie byy one zbyt rozbudowane. Wynika to przede wszystkim z chci uniknicia

pomyek typu: ktry fragment jest metod klasy zawierajcej, ktry wewntrznej,a ktry lokalnej. Oczywicie moemy jednak tworzy w ten sposb nawet bardzoskomplikowane konstrukcje formalnie nie istniejbowiem adne ograniczenia w bu-dowaniu klas wewntrznych i lokalnych.

Kompilacja kodu utworzonego na podstawie szablonu pokazanego powyej spowo-duje powstanie plikw:

Zawierajaca.classZawierajaca$Wewnetrzna.classZawierajaca$Lokalna.class

Tak wic zastosowanie klas wewntrznych zmniejszy tylko liczbplikw rdowych.Liczba plikw skompilowanych classpozostaje staa.


38/89


2.3.1. Dostp do zmiennych klasy zawierajcej

Jakkolwiek oglne zasady tworzenia klas wewntrznych i lokalnych s takie same,tak jak dla zwykych klas istnieje kilka szczegw, na ktre naley zwrciuwag,

bo rozszerzajmoliwoci udostpnione w czasie tworzenia tych klas. Jednym z ta-kich udogodniejest bezporedni dostp przez klasy wewntrzne i lokalne do pl klaszawierajcych. Umoliwia to uproszczenie niektrych konstrukcji i przyblienie ichdo natury programowania strukturalnego. Kilkakrotnie zwracaem juuwagna to, eJava w niektrych przypadkach bywa ortodoksyjnie obiektowa. Stosowanie klas we-

wntrznych nieznacznie agodzi te restrykcje. Warto jednak pamita, e bezporednidostp do zmiennych spoza klasy jest niezgodny z ideprogramowania obiektowego.Jeli jednak zaoymy, e klasy lokalne powstajwycznie na potrzeby klasy zawie-rajcej, w ktrej spotem uywane, moemy przyj, e nie amie to zbyt mocno re-guhermetyzacji. Przykad uycia pl przez klasy wewntrzne i lokalne pokazany jestna listingu 2.45, we fragmencie wikszej klasy.

Listing 2.45.Uywanie pl klasy zawierajcej przez klasy wewntrzne i lokalne

int i;

class Wewnetrzna { double wynik() { return (i+0.01) * 0.99; }}

void button_actionPerformed(ActionEvent e) { class Lokalna { double wynik() { return (i+0.05) * 0.; }

} Lokalna l = new Lokalna(); Wewnetrzna w = new Wewnetrzna(); for (i=0; i


39/89


int suma() { return i+j; }}

void metodaX() { int wynik;

Wewnetrzna w = new Wewnetrzna(); Wewnetrzna w2 = new Wewnetrzna(); w.setSth(10); w2.setSth(100); wynik = w.suma(); // 110, // chospodziewalimy si20 wynik = w2.suma(); // 200}

Gdyby w klasie Wewnetrznanie byo interakcji z polem klasy zewntrznej, wtedy dziaa-nie tego kodu byoby zupenie inne, nijest. Takie bdy trudno wyledzi. W zwizkuz tym sugerujjawne odwoywanie sido pl klas zewntrznych wycznie w przy-

padku, gdy mamy pewno, e bdziemy uywawycznie jednego egzemplarzaklasy wewntrznej.

2.3.2. Polimorfizm i zmienne klasy zawierajcej

Uywanie pl klasy zawierajcej powinno odbywasiz duostronociw przy-padku, gdy klasa wewntrzna dziedziczy po tak zwanej normalnej klasie. Poniej przed-stawiony jest przykad, ktry mimo tego, e bezbdnie przechodzi kompilacj(nawetz uyciem kompilatorajikesi jego opcji pedantycznej kompilacji +P), nie pracuje po-

prawnie. Najwaniejsze fragmenty, na ktre naley zwrciuwag, wytuciem na li-stingu 2.47.

Listing 2.47.Bdne uycie pl klasy zawierajcej

import java.applet.*;

public class Aaa extends Applet { public Integer p1 = new Integer(2p; public void init() { System.out.println("wewnatrz konstruktora apletu"); B b = new B(); } private class B extends A {

public void doSth() { System.out.println("p1=" + p1p; } }}

abstract class A { public A(pb System.out.println("wewnatrz konstruktora A"p; doSth(p; } abstract public void doSth();}


40/89


Wewntrzna klasa Bkorzysta z pola p1pozornie w sposb poprawny. Pozornie, gdyjeli cofniesz sido para

Documents

Java. Programowanie obiektowe