Programozas III

Varjasi Norbert
PROGRAMOZS III.
Objektumorientlt programozs
Java nyelven
Kszlt a HEFOP 3.3.1-P.-2004-09-0102/1.0 plyzat tmogatsval.
Szerz:
Varjasi Norbert
egyetemi tanrsegd
Lektor:
Pusztai Pl
egyetemi adjunktus
Varjasi Norbert, 2006
Marton Lszl emlkre
Programozs III.
A dokumentum hasznlata
A dokumentum hasznlata | Tartalomjegyzk | Trgymutat
Vissza
A dokumentum hasznlata
Mozgs a dokumentumban
A dokumentumban val mozgshoz a Windows s az Adobe Reader megszokott elemeit s mdszereit hasznlhatjuk.
Minden lap tetejn s aljn egy navigcis sor tallhat, itt a megfelel
hivatkozsra kattintva ugorhatunk a hasznlati tmutatra, a tartalomjegyzkre, valamint a trgymutatra. A s a nyilakkal az elz s a kvetkez oldalra lphetnk t, mg a Vissza mez az utoljra megnzett oldalra
visz vissza bennnket.
Pozcionls a knyvjelzablak segtsgvel
A bal oldali knyvjelz ablakban tartalomjegyzkfa tallhat, amelynek
bejegyzseire kattintva az adott fejezet/alfejezet els oldalra jutunk. Az
aktulis pozcinkat a tartalomjegyzkfban kiemelt bejegyzs mutatja.
A tartalomjegyzk s a trgymutat hasznlata
Ugrs megadott helyre a tartalomjegyzk segtsgvel
Kattintsunk a tartalomjegyzk megfelel pontjra, ezzel az adott fejezet

els oldalra jutunk.
A trgymutat hasznlata, keress a szvegben
Keressk meg a trgyszavak kztt a bejegyzst, majd kattintsunk a hozz

tartoz oldalszmok kzl a megfelelre. A tovbbi elfordulsok megtekintshez hasznljuk a Vissza mezt.
A dokumentumban val keresshez hasznljuk megszokott mdon a
Szerkeszts men Keress parancst. Az Adobe Reader az adott pozcitl kezdve keres a szvegben.
Vissza
Programozs III.
Tartalomjegyzk
Vissza
Tartalomjegyzk
Elsz..................................................................................................................... 8
1. A Java nyelv alapjai ........................................................................11
1.1. Trtneti ttekints....................................................................................11
1.2. A Java programok s a virtulis gp szerkezete..................................... 13
1.3. Krdsek......................................................................................................16
2. Az objektumszemllet elmleti megkzeltse ............................ 17
2.1. Az osztly s az objektum ........................................................................ 19
2.2. Egysgbezrs.............................................................................................23
2.3. Adatrejts ....................................................................................................24
2.4. rklds ...................................................................................................25
2.5. Tbbalaksg.............................................................................................. 29
2.6. Osztlyok s objektumok egyttmkdse, kapcsolatai ...................... 34
2.7. Kontner osztlyok....................................................................................35
2.8. Komponensek ............................................................................................37
2.9. Krdsek......................................................................................................37
2.10. Feladatok...................................................................................................38
3. A Java technolgirl kzelebbrl ............................................... 39
3.1. Keretrendszerek .........................................................................................39
3.2. Nyelvi alapelemek ......................................................................................40
3.3. Krdsek......................................................................................................74
3.4. Feladatok.....................................................................................................75
4. Az osztlyok hasznlata ............................................................... 76
4.1. Az osztlyok, s az objektumok letciklusa ........................................... 76
4.2. rklds ...................................................................................................81
4.3. Tbbalaksg.............................................................................................. 85
4.4. Absztrakt osztlyok ................................................................................... 95
4.5. Osztlyvltozk s osztlymetdusok ....................................................97
4.6. Krdsek....................................................................................................102
4.7. Feladatok...................................................................................................102
5. Interfszek ...................................................................................104
5.1. Interfszek deklarcija...........................................................................105
5.2. Interfszek kifejtse, megvalstsa.......................................................106
Vissza
Programozs III.
Tartalomjegyzk
Vissza
5.3. Interfszek rkldse ............................................................................109

5.4. Bels osztlyok.........................................................................................110
5.5. Krdsek....................................................................................................114
5.6. Feladatok...................................................................................................114
6. Csomagok, komponensek ........................................................... 115
6.1. A Java nyelv alapcsomagjai.....................................................................115
6.2. A fordtsi egysg.....................................................................................118
6.3. Csomagok deklarcija............................................................................119
6.4. Csomagok importlsa ............................................................................119
6.5. A jar fjlok hasznlata .............................................................................120
6.6. Krdsek....................................................................................................122
6.7. Feladatok...................................................................................................122
7. Kivtelkezels ..............................................................................123
7.1. Kivtelosztly definilsa ........................................................................124
7.2. A kivtel keletkezse, kivltsa...............................................................126
7.3. A kivtel feldolgozsa..............................................................................127
7.4. Krdsek....................................................................................................129
7.5. Feladatok...................................................................................................129
8. A Java platform hasznos lehetsgei...........................................130
8.1. Szveges adatok formzsa ....................................................................130
8.2. Naplfjlok hasznlata (logging)............................................................132
8.3. Dtum s idkezels................................................................................136
8.4. Idmrs nanoszekundumokban ..........................................................141
8.5. Tmbmveletek .......................................................................................141
8.6. Krdsek....................................................................................................145
8.7. Feladatok...................................................................................................145
9. Fejlett adatszerkezetek................................................................146
9.1. A gyjtemny keretrendszer ...................................................................147
9.2. A gyjtemny keretrendszer interfszei................................................148
9.3. A gyjtemny keretrendszer osztlyai...................................................150
9.4. ltalnostott tpusok (generics) ............................................................163
9.5. Krdsek....................................................................................................170
9.6. Feladatok...................................................................................................171
Vissza
Programozs III.
Tartalomjegyzk
Vissza
10. Az I/O s hlzatkezels...........................................................172

10.1. Adatfolyamok .........................................................................................173
10.2. Kapcsolat a fjlrendszerrel ...................................................................175
10.3. Hlzatkezels........................................................................................183
10.4. Krdsek .................................................................................................192
10.5. Feladatok.................................................................................................192
11. Fordtsi hibazenetek ..............................................................194
12. Kdolsi szabvnyok..................................................................196
12.1. Fjlnevek .................................................................................................196
12.2. Fjlok felptse......................................................................................196
12.3. Megjegyzsek..........................................................................................200
12.4. Deklarcik.............................................................................................203
12.5. Elnevezsi konvencik..........................................................................210
12.6. Programozsi tancsok .........................................................................212
12.7. Kd pldk .............................................................................................214
13. Mellkletek.................................................................................216
13.1. A Java keretrendszer teleptse s a krnyezet belltsa .................216
13.2. Dokumentcis segdprogramok........................................................218
Irodalomjegyzk ...................................................................................................223
Trgymutat ........................................................................................................225
Vissza
Programozs III.
Elsz
Vissza
Elsz
A programozsi nyelvek trtnete nem lel fel nagy idintervallumot. Az
utbbi tven v alatt nagy fejldsi vet jrtak be mind a hardver-, mind a
szoftvertervezsi mdszertanok. A szmtgpek elterjedsvel a piac egyre tbb alkalmazsfejlesztsi ignyt tmasztott. A szmtgpes programok termelshez szigor szablyok, egysges mdszertanok szksgesek.
A szoftverek tervezshez s elksztshez a modellez rendszerek ismerete szksges. A szoftverfejleszts sorn egy-egy elmleti skon brzolt
feladat magasszint modelljbl kell lekpezni a szmtgpen trolhat
adatstruktrkat s algoritmusokat az adott hardver- s szoftverkrnyezetben.
A modellalkotsnak szmos elmlete ismert. Az 1960-as vekben megjelen, majd szles krben a 80-as vekben elterjed objektumorientlt
modellezsi s programozsi szemllet j megkzeltsi mdot adott az
adatszerkezetek s az algoritmusok tervezsbe. Az j megkzelts szerint
az let szmtgpektl fggetlen, termszetes jelensgeit kell megfigyelni,
s ezeket a megfigyelseket programozsi krnyezettl fggetlenl kell
modellezni. Az gy ellltott ltalnos modellt azutn olyan programozsi
nyelven kell megvalstani, amelyek tmogatjk ezt az objektumorientlt
szemlletet. Ha nem ilyen programnyelveket hasznlunk, akkor a programozs nehzkess vlhat, az objektumorientlt rendszer elemei srlhetnek, vagy legrosszabb esetben a felvzolt modellt torztjuk el, gy pedig
nem a modell szerinti feladat lesz a vgeredmny, hanem valami ms.
Az objektumorientlt szemlletmd szaktva a strukturlt programozs
elvvel ahol egy adott feladat megoldsa fgg az implementl nyelvtl,
mert a feladatokat mindig az adott programnyelv brzolhat adatstruktrjval s utastskszletvel kszthetjk el egy gpektl s programozsi nyelvektl fggetlen modellszemlletet, modellalkotst kvetel meg a
fejleszttl. Az elll objektumorientlt modellek azutn, egy-egy adott
objektumorientlt nyelven megvalsthatak.
A Java a 90-es vek s napjaink dinamikusan fejld programnyelve.
Az Internet korban amikor lehetsgess vlt az egymssal sszekttetsben ll gpek hasznlata a Java nyelv kpes az sszekapcsolt, nylt
rendszereket hasznl szoftverek fejlesztsre. Htkznapi szemll ltal
is megfigyelhet az a folyamat, amelyben az eddig csak klnll gpeken
fut egyedi programokat, a hlzatos, kliens-szerver, vagy a napjainkra
Vissza
Programozs III.
Elsz
Vissza
elterjedt kzvetlen adatcsert lehetv tev (peer-to-peer) szoftverek vltjk fel.

A Java nyelv alkalmas az objektumorientlt alapelveknek teljes mrtkben megfelel, architektra s opercis rendszer fggetlen, hordozhat
programkd fejlesztsre. A megalkotott szoftverek brmely ms gpen lefuttathatak lesznek, amelyek tmogatjk s ismerik a Java virtulis gpet
a Java rtelmezjt.
A nyelv nylt forrs, s fejlett eszkzkszlettel rendelkezik, amelyek
segtik a hatkony s gyors programfejlesztst, melyhez mindig adottak a
legfrissebb, rszletesen kidolgozott lersok, igaz csak angol nyelven.
A jegyzet els fejezett a Java programozsi nyelv alapelemeinek vizsglatval, alapvet eszkzkszletnek bemutatsval kezdjk. Ezutn megismerkedhetnk az objektumorientlt szemlletmddal, annak fogalomkszletvel s legfontosabb alapelveivel osztly, objektum, egysgbezrs, adatrejts, rklds s tbbalaksg. Ez a fejezet mg nem tartalmaz
konkrt nyelvi elemeket, megoldsokat, hanem az absztrakt s magasszint modellalkots szerkezett s elemeit trgyalja. Tovbb nem tartalmazza az objektumorientlt elemzsi s modellezsi (OOA, OOD) mdszertanokat, illetve az UML teljes specifikcijt, csupn az objektumorientlt
modellek programozshoz szksges osztlymodelleket trgyaljuk.
Az elmleti ismeretek utn rtrnk azok Java krnyezetbeli trgyalsra.
Az objektumorientlt elmleti alapelemeknl felrajzolt vet kvetve megismerjk, hogy a Java nyelv a magas szint modellek lekpezshez milyen
eszkztrat ad a programoz kezbe.
Az ezt kvet fejezetek a Java keretrendszer egy-egy klnll fejezetnek lerst tartalmazzk. Megismerkednk tbbek kztt a magas szint adatbrzols eszkzeivel, a fjl- s a hlzatkezelst tmogat csomagokkal, s minden olyan nyelvi elemmel, amely a leggyakrabban elfordul
algoritmizlsi s programtervezsi feladatokban felhasznlhat.
A jegyzetben a hivatkozsoknl a kvetkez jellsrendszert alkalmaztam: A nyomtatott irodalmakat a szerz nevvel s a kiads vszmval
kzlm pl: [Angster01], az internetes hivakozsokat sorszmozssal jellm pl: [2], illetve abban az esetben, ha egy konkrt Java kiadsra jellemz
fogalmat trgyalunk, azt (Java1.4) alakban jelzem.
A jegyzet clja, hogy az objektumorientlt programfejlesztsi technikkkal ismerked informatikus hallgatk tfog kpet kapjanak a Java
programnyelvrl s a mgtte ll szemlletrl. A tmakrt nem trgyaljuk a teljessg ignyvel, hiszen az elmlt vtizedekben szmos magyar s
Vissza
Programozs III.
Elsz
Vissza
10
angol nyelv knyv, [Angster01, Flanagan05, Kondorosi04, Lemay02,

Nyky01, Schildt03, Vg99] s online segdanyag [1], [8], [9] kerlt az olvask el. Ezt az elekronikus jegyzetet a felsorolt mvek alapjn rendszereztem. A trgyals sorn igyekeztem a legfrissebb kiadsok (Java5, Java6)
jdonsgaira is kitrni [12], [13].
Vissza
10
Programozs III.
A Java nyelv alapjai

Vissza
11
1. A Java nyelv alapjai

Az alkalmazsfejlesztshez valamilyen konkrt nyelvi interpretcit kell
kszteni. Az objektumorientlt elveket a 70-es vektl kezdden kezdtk bepteni az egyes programnyelvekbe, s ekkor kszlt az els tisztn
objektumorientlt nyelv is. A hatkony, objektumorientlt nyelvek sorban
a 90-es vekben jelent meg a Java, amely mint az internet-korszak egyik
ttr nyelve az utbbi vekben ltvnyos fejldsen ment keresztl, s
napjainkban is nagy npszersgnek rvend. Elszr tekintsk t a Java
nyelv kialakulsnak rvid trtnett.
1.1. Trtneti ttekints
Patrick Naughton s James Gosling (SUN Microsystems Green Team)
1991-tl egy mini kommunikcis nyelvet kezdtek kifejleszteni [10]. Cljuk egy hatkony, architektra-fggetlen, kis erforrs-igny rendszer
kifejlesztse volt, melyet egyszer elektronikai eszkzkben szerettek volna felhasznlni (digitlis kbel-TV vgponti eszkzk).
Alaptletk lnyege (Niclaus Wirth pascal nyelvi kdja alapjn) a kvetkez modellen alapult: egy elkpzelt, hipotetikus gpre kzbens kdot
generlnak (Java Virtual Machine JVM), amely azutn minden olyan
architektrn s opercis rendszeren mkdkpes, amely rendelkezik
ezzel az interpreterrel.
Az interpreter (rtelmez) olyan program, amely a forrsprogramnak egyszerre egyetlen utastst rtelmezi. Az utastst natv kdd alaktja, s
azonnal vgrehajtja. A lefordtott kdot nem jegyzi fel, hanem vgrehajts
utn kzvetlenl eldobja, s a kvetkez utasts feldolgozsba kezd.
A virtulis gp s az interpreter jelleg azrt volt dnt s hatkony lps,
mert az elektronikai piac az 1980-as, 90-es vekben ugrsszer fejldsen
ment keresztl, a hardverek tern nagyfok architekturlis eltrs mutatkozott. Ezt a klnbsget hidaltk t azzal, hogy a nyelvet ltalnoss tettk, s minden hasznlt architektrra elksztettk a virtulis gpet. gy a
programok nemcsak forrs szinten, hanem a lefordtott trgykdok szintjn vltak szabadon hordozhatv. Ez az jts az olyan htrnyai ellen-
Vissza
11
Programozs III.

Vissza
12
re, mint pldul a lasssg fontos szerepet jtszott ksbb, a nyelv gyors
elterjedsben.
A virtulis gp a Java alkalmazsok futtatsra kpes, ltalban szoftveresen megvalstott mkdsi krnyezet. A virtulis gp feladata a Java
osztlyokat tartalmaz .class llomnyok betltse, kezelse, valamint az
azokban tallhat Java kdban adott mveletek gpi kd utastsokk
trtn talaktsa.
Gosling ezt az alapelvet az rd meg egyszer, futtasd brhol kifejezssel magyarzta. Mivel a kutatsban rszt vev fejlesztk C++ programozk voltak, gy a kifejlesztett j nyelvhez a C++ nyelv alapjait hasznltk
fel kiindulsknt, ezt egyszerstettk, alaktottk. Cljuk egy olyan nyelv
megalkotsa volt, ami tisztn objektumorientlt, s amelyben a gyakran
elfordul programozsi hibk mr fordtsi idben kiderlnek. Kezdetben Oak (tlgy) nvvel illettk az elkszlt nyelvet, de ez a sz mr foglalt
volt. A Java nvvlaszts a fejlesztk kvzsi szoksbl ered. (Jva szigetrl szrmaz kvt fogyasztottak az j nv kivlasztsakor.)
Az j nyelv elksztse mg nem jelentett egyrtelmen szleskr elterjedst akkor sem, ha az a nyelv, illetve a kidolgozott technolgia hatkony. Az elkszlt eszkz (Set Tob Box interaktv kbeltelevzis rendszer) messze megelzte a kort, mert a 90-es vek elejn az ipar s a piac
(konkrtan a kbeltelevzis rendszerek) mg nem ismertk fel ebben az j
technolgiban rejl lehetsgeket.
A nyelv ismertsge s gyors elterjedse annak volt ksznhet, hogy a
90-es vekben rohamosan fejld web-alkalmazsokra is felksztettk.
Ekkoriban vlt ugyanis npszerv a hipertext, s a web-bngszkbe
belecsempszett, bepl JVM-ek (HotJava Browser, Netscape stb.) letre
keltettk az addig statikus lapokat. Vagyis a Java-kpes bngsz motorok
kpesek voltak a HTML-oldalakba ptett, elre lefordtott bjtkdok futtatsra, animcik, mozg brk, zenk s videk formjban (az
appletek 1995-96-tl) jelentek meg.
A Java programozsi nyelvet 1995 mjusban adta ki a Sun Microsystems, ekkor mr a fbb gyrt s feljesztcgek bejelentettk a Java
technolgival val egyttmkdst (Netscape, Oracle, Toshiba, Lotus,
Borland, Macromedia, Silicon Graphics, Symantec, IBM, Adobe, Microsoft stb.).
1998-tl mkdik a Java Community Process (JCP), mint a Java fejlesztseket sszefog, tbb nagyvllalatot s szmos kutatintzetet, valamint egyni fejlesztt sszefog fggetlen szervezet.
Vissza
12
Programozs III.

Vissza
13
1999-ben a Java2 rendszer kiadsakor mr hrom fggetlen rszre

bontottk a Java technolgit. gy az ME (Micro Edition) a begyazott
eszkzk, a SE (Standard Edition) az ltalnos desktop-programok, s
az EE (Enterprise Edition) a kliens-szerver, illetve nagyteljestmny
vllalati alkalmazsok fejlesztshez nyjt hatkony krnyezetet. Azonban
hamarosan negyedik f irnyknt vizsglhatjuk a Java Card rendszereket, vagyis az intelligens chipkrtyk programozsi platformjt.
A nyelv nagyon gazdag eszkzkszlettel tmogatja a programozi
munkt, a begyazott rendszerek programozstl, mint a mobiltelefonok
s kziszmtgpek (PDA-k) az elosztott s nagy erforrsigny zeti
webszolgltatsokig, illetve a kliens-szerver alkalmazsokig. A Java nyelv
fejlesztse nem llt meg. A JCP keretben a mai nap is kzel ezer, egymssal prhuzamosan foly projektet fejlesztenek. Napjainkban a Java a tzves jubileumt nnepli, a honlapjn kzztett adatok szerint az aktv Java
programozk szma 4,5 milli krli, s jelenleg forgalomban van krlbell 2,5 millird Java-kpes eszkz. A felsorolt szmadatok azt vettik
elre, hogy a Java technolgia nagy iram fejldse nem ll meg, s a jvben nagy szksg lesz a nyelvet ismer szakemberekre.
Az albbiakban a Java programnyelv alapvet felptst s ptkveit
igyekszem bemutatni.
1.2. A Java programok s a virtulis gp
szerkezete
Mint minden programozsi nyelvhez, gy a Java nyelvhez is szksges
valamilyen fejleszti krnyezet, amely a forrsprogramok fordtst, illetve
futtatst lehetv teszi. A Java fejleszti csomag (Java Software Development Kit SDK) teleptse, s a szksges krnyezet belltsa utn (a
rszletes teleptsi tmutatt lsd a Mellkletekben) az elkszlt forrskdot lefordthatjuk.
A nyelv megalkoti a virtulis gpet egy kpzeletbeli szmtgpknt
rjk le. Ezt a szmtgpet szimulljuk szoftveresen valamilyen konkrt
rendszeren. A virtulis gp mr elzetesen lefordtott trgykd, (bjtkd) binris llomnyokkal (tovbbiakban class fjl) dolgozik. A virtulis
gp indtsakor a paramterknt megadott publikus osztly mveleteit
kezdi el vgrehajtani. A vgrehajts sorn a virtulis gp ms osztlyokat is
betlthet, objektumokat pldnyosthat, zeneteket kldhet stb.
Vissza
13
Programozs III.

Vissza
14
Ugyanaz a Java forrsprogram brmilyen fordtval lefordtva ugyanazt

a class fjlt lltja el bjtrl-bjtra. A virtulis gpen futtatva pedig ugyanazt az eredmnyt kapjuk brmilyen krnyezetet is hasznljunk (architektra, opercis rendszer). A kzs bjtkd hasznlata teht hordozhat kdot nyjt. Tovbb a kis mretek miatt a trgykd tmr, s optimalizlt
a class fjlok hatkonyan tovbbthatak hlzatos krnyezetben. A Java
gyors elterjedsnek ez a platformfggetlensg s hatkonysg volt az
egyik oka.
Az interpretereken kvl termszetesen lteznek olyan eszkzk is (Java processzorok), amelyek hardveresen tmogatjk a trgykd fjlokat, vagyis az eszkz gpi kdja maga a JVM (mobiltelefonok, kzi szmtgpek, clhardverek). Tovbb lteznek olyan eszkzk is, amelyek a Java
kdot egy adott rendszer binris kdjra fordtjk.
Egy konkrt java forrskd lefordtshoz a java krnyezet /bin knyvtrban tallhat javac (javac.exe) fordtprogramot hasznljuk.
A fordts utn egy class fjlt kapunk. A class llomnyokat a szmtgpnk kzvetlenl nem tudja feldolgozni, szksge van egy kzbens
interpreterre, amely a binris kdot az adott architektra szmra rtelmezhet utastssorozatra alaktja. Ez az eszkz a virtulis gp (JVM). A
virtulis gp a Java krnyezet /bin knyvtrban tallhat, s a java
(java.exe) paranccsal indthat. A parancs paramtere egy mr lefordtott Java osztly neve lehet.
1. bra: Java programok fordtsa s futtatsa a virtulis gpen

A virtulis gp a class fjl betltsekor az rkez kdot szigoran ellenrzi, majd a szksges memriaterletet inicializlja, s az rkez utastssorozatot vgrehajtja.
A fejlesztk a nyelv, s a java krnyezet tervezsnl a kvetkez tizenegy szempontot tartottk szem eltt:
Vissza
14
Programozs III.

Vissza
15
Egyszer: A nyelv a C++ (mint a 90-es vek legnpszerbb s legelterjedtebb krnyezete) egyszerstett vltozata. A Java nyelv sokkal kevesebb nyelvi eszkzt sokkal nagyobb ktttsgekkel tartalmaz.
Objektumorientlt: A Java tisztn objektumorientlt nyelv, egy Java
alkalmazs nem tartalmaz globlis, illetve osztlyokhoz nem kthet
kdot.
Elosztott: A Java alkalmazsok kpesek hlzatos krnyezetben, az
internet egysges erforrs azonostival (URL Uniform Resource
Locator) egyrtelmen azonostott objektumokat kezelni. A Java rendszer tovbb kpes a tvoli eljrshvson alapul kliens-szerver jelleg
alkalmazsok kifejlesztsre.
Robusztus: (hibatr, megbzhat): A nyelv tervezsekor fontos
szempont volt a programozi hibk mr fordtsi idben val kiszrse, a futsi idej hibk minimalizlsa.
Biztonsgos: A nyelv mr kezdeti szakaszban tmogatta a hozzfrsek s jogosultsgok kezelst. A Java krnyezet a hlzatos alkalmazsok s elosztott rendszerek tmogatsa mellett hatkony biztonsgi megoldsokkal rendelkezik. Az osztlyok virtulis gpbe tltsekor (Class loader) hibaellenrzs trtnik, s a virtulis gp az adott
opercis rendszer felett az n. homokverem (sandbox) modell szerint
mkdik, amely azt jelenti, hogy a fut programok az opercis rendszer egy kijellt s lahatrolt terletn futnak, gy kptelenek a gazdagp erforrsaihoz kzvetlenl hozzrrni.
Hordozhat: A Java nyelv s a programozsi krnyezet nem tartalmaz implementcifgg elemeket. Egy adott forrsbl minden Java
fordt ugyanazt a trgykdot lltja el.
Architektra-fggetlen (gpfggetlen): A fordts sorn az azonos
tpusok minden krnyezetben azonos mret memriaterletet foglalnak, a fordts utn elll class fjlok brmelyik szabvnyos virtulis
gpen futtathatak. A futtat krnyezet a trgykd llomnyokat
azonos mdon hajtja vgre. Az egyes architektrkhoz s opercis
rendszerekhez elksztett virtulis gpek alaktjk t a class llomnyokat natv kdokra.
Interpretlt: Az egyes hardvereken fut natv kdot a virtulis gp
futsi idben hozza ltre, a lefordtott trgykd llomnyokbl.
Nagy teljestmny: Ez az utols jellemz mg nem kerlt teljes
mrtkben megvalstsra. A Java krnyezet kritikusai az interpretlt
Vissza
15
Programozs III.

Vissza
16
jellegbl add lass futst s az optimalizls nehzkessgt nagy hibnak rjk fel, azonban a processzorok fejldsvel, s a Just In Time
(JIT) fordtk kutatsba fektetett erforrsokkal a Java fejleszti a jvben ezt a szempontot is meg szeretnk valstani. A JIT fordtk a
lefordtott trgykdokat a futs alatt megrzik, optimalizljk.[5]
Tbbszl: A Java krnyezet tmogatja a prhuzamos programozst,
s alkalmas prhuzamos algoritmusok megvalstsra. Ezt az adott
hardveren gy valstja meg, hogy egy idben egymstl fggetlenl
tbb programrszt futtat. Egyprocesszoros rendszereknl ezt termszetesen egyms utni vgrehajtssal, a szlak temezsvel oldja meg.
Dinamikus: Az osztlyknyvtrak szabadon tovbbfejleszthetk, s
mr a tervezsnl figyelembe vettk, hogy egy esetleges ksbbi bvts a mr megalkotott programok mkdst ne akadlyozza.
A Java programok forrsszvege a C, C++ nyelvhez hasonlan egy
tiszta karaktersorozat. Az egyes nyelvi elemeket fehr karakterekkel (szkz, tabultor, soremels) tagoljuk, illetve vlasztjuk el egymstl. A program rsakor be kell tartanunk a nyelv szablyait, s rdemes figyelembe
venni a Java nyelv kdolsi konvenciit (lsd: Kdolsi szabvnyok).
A szintaktikai szablyok szigoran meghatrozzk, hogy milyen elemeket, azonostkat milyen sorrendben alkalmazhatunk a forrskdban.
Szintaktikai hiba pldul, ha egy azonostt hibsan runk le. A szintaktikailag hibs program nem fordthat le rvnyes class fjl formtumba.
A szemantikai szablyok a program mkdsi elvt, futst hatrozzk
meg. Ezek a hibk fordtskor ltalban nem derthetek ki, csak a futs
kzben jelennek meg. Pldul ha a programban egy a/b alak kifejezsben
0-val val osztst ksrelnk meg vgrehajtani.
1.3. Krdsek
Milyen formtum egy lefordtott java forrs?

Mi a Java technolgia hrom f irnya?
Melyek az interpretlt programok fbb jellemzi?
Mi a szerepe a virtulis gpnek?
Mi a klnbsg a szintaktikai s a szemantikai programhiba kztt?
Vissza
16
Programozs III.
Az objektumszemllet elmleti megkzeltse
Vissza
17
2. Az objektumszemllet elmleti
megkzeltse
Az elz fejezetben megismerkedtnk a Java krnyezettel, ttekintettk a
trtneti vonatkozsokat s a mkds fbb alapelveit. Maga a Java nyelv
egy tisztn objektumorientlt programozsi nyelv. Az objektumorientlt
programozs elsajttshoz szksgnk van a nyelv jelkszletnek s mkdsi elvnek megismersre.
Az objektumorientlt alapelvek s modellek azonban rvnyesek
konkrt programozsi nyelv nlkl is, hiszen alkalmazsuk magasabb szint, ltalnos megoldsokat nyjt. Ebben a fejezetben ennek a gondolkodsmdnak mskppen programozsi paradigmnak alapelveivel ismerkednk meg.
A programozs hskorban a programok csupn nhny szz soros,
alacsonyszint utastssorozatbl lltak. A magasszint, strukturlt programnyelvek megjelense az 1960-as vektl kezdve knnyebb s hatkonyabb programozsi technikkkal ltta el a szakembereket. A konstansok, vltozk vezrlsi szerkezetek s a szubrutinok megjelense nagyobb
s sszetettebb problmk megoldst tette lehetv: a feladatok magas
szint modellezst s algoritmizlst. A kalsszikus strukturlt programozs szablyai szerint a megoldand feladatokat t kell alaktani szmtstechnikai modell, azaz a megoldshoz felhasznlt gp szmra rtelmezhet adatokra, illetve az ezekkel az adatokkal, a feladatot elvgz algoritmusra. A megvalstshoz szmos programnyelv kszlt, s ahogy ntt a
szmtgpekkel elvgzett feladatmegoldsok szma, az egyes programozsi nyelvek is gy vltak sszetettebbek, ltalnosabb.
Megjegyzs: Struktrltnak tekinthet az a program, amely vezrlsi szerkezetknt megengedi a szubrutinhvsokat, a szekvencia, a szelekci, az
iterci utastsokat, de ms vezrlstad utastsokat (pl. ugr utasts)
nem. [Marton02]
A 80-as vekre az elkszlt programok mrete s sszetettsge akkorra
ntt, hogy mindinkbb szembetlttek a strukturlt programtervezs korltai. Ezt az idszakot a szoftverkrzis idszaknak is neveztk, gyakori
volt a hatridk csszsa, az eredmnytelen fejleszts s a kltsgvetsek
Vissza
17
Programozs III.
Vissza
18
tllpse, hiszen a tlsgosan bonyolultt vl rendszerek modellezsre,

majd tesztelsre illetve a hibk javtsra nem fordtottak kell erforrst. Ezek a rendszerek tipikusan egy emberes munkk voltak, s ebbl
addan nagyobb, tfogbb feladatokhoz mr nem voltak hatkonyak,
hiszen a programok szma s mrete nagysgrendekkel gyorsabban ntt,
mint a programozi kapacits. A felmerl problmkat igyekeztek valamilyen szabvnyosts vagy j mdszertan segtsgvel megoldani, illetve
jrahasznosthat kdokat tervezni.
A programozsi nyelvek trtnetben az 1960-as vektl a 80-as vek
elejig (Simula, Smalltalk nyelvek) figyelhet meg az a folyamat, amikor a
strukturlt programozsi mdszerek mellett megjelent egy j elgondols,
egy j szemllet, amelyet objektumorientlt programozs nvvel illetnek
mind a mai napig.
A megolds nem technikai jelleg a hangsly nem ott van, hogy az
egyes programnyelvekbe j elemeket ptenek hanem mdszertani ksrlet volt annak a problmnak a feloldsra, hogy a modellalkotsban a
hagyomnyos skon nem mindig lehet az adott problmkat hatkonyan
megkzelteni. Magt a vals vilgot kell minl hebben lerni, modellezni.
Az objektumorientlt modell a vals elemeket, trgyakat, objektumokkal
brzolja, amelyeket egyes llapotaik, jellemzik, adataik s az ezekhez az
objektumokhoz egyrtelmen hozzrendelhet mveletek rnak le.
Az objektumorientlt modellalkots s programozs megjelense j
fogalmakat is bevezetett. Az osztly, az egysgbezrs, az rkls, a tbbalaksg, a futs alatti kts, az zenetklds, az egyttmkds, az interfszek, a csomagok s komponensek fogalma mind-mind az j szemllet
jegyben szlettek. Az j fogalom- s szhasznlat egy msfajta gondolkodsmdot jelez. Az objektumorientlt modell egy j szemlletmdot
vezetett be a feladat- s rendszermodellezsbe is. A modellalkotk egy
kevsb absztrakt s a vals problmkhoz jobban illeszked s knnyebben ttekinthet mdszert alkottak. A 80-as 90-es vek alatt szmos
meglv programozsi nyelvbe beszrdtt ez a szemlletvlts (Object
Pascal, Delphi, C++, Ada, C#, PHP), illetve megszlettek a tisztn objektumorientlt nyelvek is (Smalltalk, Eiffel, Java).
A programozsi nyelveknek ez a gyors talakulsa nem abbl az okbl
ered, hogy a hagyomnyos mdszertanok hibs alapokra pltek, vagy
mra mr elavultt vltak. A vlaszt inkbb a szmtstechnikai eszkzk
gyors terjedsben, a megoldand feladatok sszetettsgben s a hatkony s jrahasznlhat programokra irnyul piaci igny oldaln clszer
Vissza
18
Programozs III.
Vissza
19
keresni. Az objektumorientlt programokban hiszen ptkvei a strukturlt programozsbl szrmaznak ppgy megtalljuk a strukturlt
alapelemeket, algoritmusokat, mint a hagyomnyos programokban. Mgis
egy msik vilgban talljuk magunkat.
Az objektumorientlt programozs a mai szoftverfejleszts legelterjedtebb mdja. Ennek a legfbb oka az, hogy az osztlyhierarchik segtsgvel hatkonyan tmogatja az absztrakt objektumok kialaktsval. Az jrafelhasznlhat kdok, csomagok s komponensek tmogatsval nagymrtkben tudja cskkenteni a fejlesztshez szksges idt.
Az albbiakban egy tmr ttekintst tallunk az objektumorientlt
szemllet legfontosabb alapelveirl. A fogalmak tisztzsa sorn mg nem
lesz sz egyes programnyelvi elemekrl, hiszen az albbi elveket minden
nyelv majd a maga mdjn valstja meg.
2.1. Az osztly s az objektum
A vals vilg lersban az emberi gondolkodst kvetve osztlyozhatjuk, csoportosthatjuk a ltottakat, a modellezs sorn absztrakt fogalmakat s ltalnostott tteleket llthatunk fel. Az absztrakcis modellezskor az sszetett s bonyolult dolgokat egyszerstjk, s csak a feladat
szmra informcival br rszleteit hasznljuk fel.
Ha pldul egy tkeresztezds forgalmt figyeljk, akkor nem fontos,
hogy egy jrm hny alkatrszbl ll, mennyire sszetett s hogy hny
klnbz jellemzje van, pontszernek tekinthetjk. Annyi azonban
fontos lehet, hogy a jrm szemly-, vagy tehergpkocsi.
Ms esetben a vilg sszetett dolgait rszekre kell bontanunk. A specializl modellezskor ezeket a rszeket valamilyen szablyok mentn
sszekapcsoljuk, hiszen a problma megoldshoz elengedhetetlennek
bizonyul.
Fenti pldnkat folytatva egy gpkocsi diagnosztikai mhely szmra
mr nem elgsges a fenti modellalkots, itt mr egy gpkocsit elemeire
kell szednnk, s meg kell figyelnnk ezen alkatrszek tulajdonsgait, mkdst.
Az objektumorientlt modellalkotsban objektumoknak nevezzk azokat a dolgokat, amelyekhez a vals vilgban egy-egy nll dolgot (jelentst, tartalmat, vagy fogalmat) rendelhetnk. A szakirodalomban egyarnt
tallkozunk az objektum, a pldny, vagy az egyed kifejezssel is. Az objektumokat valamilyen mrhet tulajdonsgval jellemznk, s megfigyeljk, hogy egy kls esemnyre (zenetre) hogyan reaglnak. A reakci az
Vissza
19
Programozs III.
Vissza
20
objektumok tulajdonsgait megvltoztathatja, vagy valamely ms objektum

fel jabb zenet kldsre indthatja.
Az objektumok informcikat trolnak, s krsre feladatokat hajtanak
vgre. Programozsi szempontbl egy objektumot adatok, s az ezen adatokon vgrehajthat mveletek sszessgvel jellemznk. Minden objektum egyedileg azonosthat.
A modellezs folyamata az adott feladat absztrakcis s specializl feldolgozsbl ll, vgeredmnye mindig valamilyen osztlyozs. Ez az osztlyozs kveti a hagyomnyos emberi gondolkodsi struktrkat. A hasonl vagy ugyanolyan tulajdonsgokkal (adattagok, attribtumok) rendelkez s hasonlan, vagy ugyangy viselked (metdusok) objektumokat
egy csoportba, egy osztlyba soroljuk. A pldnyok rendelkeznek a sajt
osztlyaik sajtossgaival, valamint az rkez zenetekre hasonl mdon
reaglnak. Tmren fogalmazva elmondhatjuk, hogy minden egyes objektum egy-egy osztly egyetlen, s egyedi pldnya.
2. bra: Egy osztly s objektumai (modell)
Vissza
20
Programozs III.
Vissza
21
Az brn fkat vizsglunk. Minden fa egyedi, hiszen megllapthatunk

kzttk eltrseket sznre, formra stb. de mgis a nvnyek egy jl krlhatrolhat osztlyt alkotjk. A fk osztlya mr egy absztrakt fogalom, hiszen magas szinten foglakozik az osztly jellegzetessgeivel, tulajdonsgaival. (Programozsi szempontbl az osztlyokat tpusdefinci segtsgvel rjuk le.)
Az osztly az ugyanolyan jellemzkkel, tulajdonsgokkal (adattagok) s
ugyanolyan mkdssel (metdusok, tagfggvnyek) rendelkez objektumok magasabb szint egysge. Minden objektum valamilyen osztly pldnya, rendelkezik az osztly tulajdonsgaival, mveleteivel.
Tekintsnk az albbi pldt: Egy iskola tanulit vizsgljuk, itt minden gyerek egy-egy nll, egyedi pldny, nll objektum. Ha ezeket a tanulkat
osztlyozni szeretnnk, akkor tbbfle megkzeltst is vlaszthatunk.
Els rnzsre ltalnost modellezs megllapthatjuk fbb tulajdonsgaik s viselkedsk alapjn, hogy mindannyian egyetlen osztlyba sorolhatak: gyerekek, hiszen mindegyik azonos iskolba jr, s hasonl
tevkenysgekben vesznek rszt s egyrtelmen elklnthetk ms osztlyok egyedeitl (objektum), pldul a tanraiktl. Mgis, ha jobban szemgyre vesszk ezt a csoportot specializl modellezs akkor nagyon
knnyen jabb osztlyokba sorolhatjuk ket mondjuk letkor szerint. Itt
mr megfigyelhetek lesznek az letkori sajtossgok szerinti klnbsgek,
az azonos utastsokra val msfajta reaglsok.
Az osztlyozst azonban mindig az adott feladatnak megfelelen kell elvgezni az ltalnost, vagy a specializl modellezs segtsgvel. A megoldsok sorn clszer a feladat szempontjbl leghatkonyabb osztlyozst
megadni.
Megjegyzs: Az osztlyozs nem minden esetben trivilis mvelet. Az
OOA (Object Oriented Analysis), s az OOD (Object Oriented Design)
modellez ismeretek segtsgvel a tervezs tlthatbb, ezrt minden
szempontbl rdemes mlyebben megismerni ezeket a mdszertanokat.
Vissza
21
Programozs III.
Vissza
22
3. bra: Az osztly jellse

Maga az osztly teht egy absztrakt adat- s mvelethalmaz. Msknt fogalmazva az osztly egy olyan tpusdeklarci, amely mintul szolgl az
ezen tpushoz tartoz objektumok (pldnyok) ltrehozshoz.
4. bra: Az objektum (pldny) jellse

A programfejleszts szempontjbl a pldnyosts folyamata sorn ltrehozzuk az egyes osztlyok konkrt pldnyait. Itt mr megtrtnik a trhelyfoglals, s a pldnyostott objektum mr egyrtelmen ismeri az
osztlyhoz tartoz mveleteket. Msknt fogalmazva a pldnyosts
utn minden egyes objektum tudja, hogy melyik osztlyhoz tartozik.
5. bra: A pldnyosts
Az objektumok lettartamuk sorn mindig valamilyen bels llapotban
vannak. A feladatvgzst minden esetben egy kezdllapotbl kiindulva
rtelmezzk. Az objektum ezt a kezdllapott, illetve a ksbbiekben a
bels llapott egy-egy zenet hatsra mdosthatja.
Vissza
22
Programozs III.
Vissza
23
Az zenet az objektumok kztti kommunikci, adatcsere, illetve egy

feladat elvgzsre val felkrs.
Az egymssal kapcsolatban ll objektumok kommuniklhatnak, zenetet
kldhetnek egymsnak. Ezeket a mveleteket az objektumorientlt nyelvek tbbnyire az objektum metdusainak (ms terminolgia szerint tagfggvnyeinek) hvsval valstjk meg. Az zenethvst mindig egy olyan
objektum kezdemnyezi, amelyik kapcsolatban ll a hvand objektummal.
Ezt a szakirodalom ismertsgi, vagy tartalmazsi kapcsolatnak definilja.
Az osztly s az objektum fogalmnak trgyalsa utn mr megfogalmazhatjuk, hogy mit is takar egy objektumorientlt program.
Egy objektumorientlt program egymssal kommunikl objektumok
sszessge, melyben minden egyes objektumnak jl meghatrozott feladatkre van. Az objektumok kztti kommunikcit a szabvnyos zenetklds valstja meg. Az objektumorientlt program nem srtheti meg
az objektumorientlt alapelveket.
2.1.1. Jellsrendszer
Az osztlyok grafikus megjelentshez az egysges modellez nyelv - az

UML (Unified Modeling Language) modellezsi smit hasznljuk. (Rszletesen lsd: [3]).
Az osztlyok s a pldnyok lerst osztlydiagramokkal, az objektumok s magasabb szinten, az osztlyok kzti zenetcsert egyttmkdsi
diagramokkal brzoljuk. Itt kln nem trnk ki az UML alap tervezs
minden egyes lehetsgre (esethasznlati-, objektum-, szekvencia-, tmenet- s aktivits diagramok).
2.2. Egysgbezrs
Az egysgbezrs (encapsulation) az egyik legfontosabb objektumorientlt
alapfogalom. Az adatstruktrkat s az adatokat kezel mveleteket egy
egysgknt kell kezelni. Az objektumok bels llapota adattagjainak futs alatti pillanatnyi rtke s viselkedse minden egyes objektum belgye. Minden objektumnak vdenie kell bels adatait. Az egyes mveleteket gy definiljuk, hogy az kizrlag a bels adatokkal dolgozzon. Minden egyes adatot s minden egyes mveletet egyrtelmen valamilyen osz-
Vissza
23
Programozs III.
Vissza
24
tly rszeknt kell rtelmezni. Ezzel a megkzeltssel az objektumorientlt rendszerek a vals vilg modellezsnek egy hatkony s ttekinthet
lerst adjk.
Az egy osztlyban definilt adattagok s a hozzjuk tartoz mveletek
(metdusok) sszetartoznak, zrt s sztvlaszthatatlan egysget alkotnak.
Az egyes hibrid objektumorientlt nyelvekben (Object Pascal, Delphi,
C++, C#, PHP) az egysgbezrst a hagyomnyos, sszetett adatszerkezetek (struktrk, rekordok) kibvtsvel valstottk meg. A tisztn objektumorientlt nyelvekben a modellek lerst csak osztlyokban adhatjuk
meg, nll, vagy globlis adatokat s mveleteket nem definilhatunk.
2.3. Adatrejts
A msodik objektumorientlt alapfogalom az adatrejts (data hiding) szorosan kapcsoldik az egysgbezrshoz. Elzleg utaltunk r, hogy az
adatokat minden egyes objektum elrejti a klvilg ell. Ez azrt szksges,
hogy egy adatot kvlrl ne lehessen mdostani, manipullni, csak valamilyen ellenrztt zeneten keresztl. Segtsgvel egy objektum csak olyan
zenetre reagl amit ismer, s az rkez zenetet ellenrzs utn vgrehajtja. Az adatok ellenrzse azonban itt is a programoz feladata! Az
adatrejts elvnek betartsval mellkhatsknt a program tbbi rszt
is vdhetjk az adott objektumban fellp hibktl, gy a fejlesztsek sorn a hiba forrsa knnyen azonosthat lesz.
Minden objektum vdi a bels adatait, gy adatstruktrja kvlrl nem
rhet el. Ezekhez az adatokhoz csak a sajt mveletei frhetnek hozz.
Az egyes nyelvekben az adatrejtst a lthatsgi szablyok definiljk. A
hozzfrsi kategrik mind az adatok, mind a metdusok szmra hasznlhatk. A legfbb kategrik a nyilvnos (public), jellse: +; a vdett
(protected), jellse: # s a privt (private), jellse: . Az egyes programnyelvek megadhatnak ennl tbb, illetve kevesebb kategrit, illetve
definilhatnak msfajta hozzfrsi mdokat is. Az adatrejts elvnek
megsrtse olyan szemantikai hibkhoz vezethet, amelyek nehezen felderthetk, illetve csak huzamosabb hasznlat utn vletlenl okoznak
Vissza
24
Programozs III.
Vissza
25
futsi hibkat. (Tbb nyelv mr a fordts sorn hibaknt jelzi az ilyen

jelleg hibkat.)
2.4. rklds
Az objektumorientlt szemllet nagyon fontos eleme az rklds
(inheritance). A modellezs sorn a vals vilg elemeit az objektumokat
valamely tulajdonsguk alapjn osztlyokba szervezhetjk. A fentiekben
mr utaltunk az ltalnost, vagy a specializl modellezsi mdszerekre,
azaz egy adott osztly ltal reprezentlt tartalmat szkthetjk, illetve rszletezhetjk.
Az rklds segtsgvel egy osztlyhoz alosztlyokat rendelhetnk.
Az jonnan megalkotott osztly minden esetben egy msik osztly kiterjesztse. A szoksos terminolgia szerint az osztlyokat s-leszrmazott,
szl-gyerek fogalomprokkal jellemezzk.
Az rklds ltalnos fogalmhoz hasonlan, a leszrmazott osztly
is rkli snek minden tulajdonsgt s mveleteit. A leszrmazott osztly objektumai teht szrmazsuk miatt reaglnak az sben definilt
zenetekre. Az rkls sorn a leszrmazott osztlyok kiterjeszthetek, j
tulajdonsgokkal rendelkezhetnek s j mveleteket is vgezhetnek. gy a
leszrmazott osztly pldnyai a kiterjeszts sorn a definilt sajt tulajdonsgokon tl az stl rklt adattagokat s metdusokat is elrhetik.
Az osztlyok leszrmaztatsval a leszrmazott osztly rkli snek minden egyes tulajdonsgt, mvelett. A leszrmazott osztly j tulajdonsgokkal s j mveletekkel bvthet.
Legyen N osztly a termszetes szmokat ler osztly. Ez az osztly tartalmaz egy nemnegatv egsz adattagot, s rtelmezhetjk rajta az sszeads, a szorzs, illetve korltozottan a kivons mvelett. Ennek leszrmaztatsval, kiterjesztsvel megalkothatjuk az egsz szmok brzolsra szolgl Z osztlyt. Itt mr eljeles egsz szmokkal dolgozunk. A leszrmazott osztly rkli az sszeads s a szorzs mvelett. A kivons
mvelett pedig felldefinilhatjuk, hiszen a mvelet itt mr a matematikai megkzelts analgija alapjn korltozsok nlkl hasznlhat.
Ezutn a Z osztlyt tovbb specializlhatjuk, ltrehozva a tovbbi szmhalmazokat ler osztlyokat.
Vissza
25
Programozs III.
Vissza
26
Egy meglv osztlyt felhasznlhatunk rktsi cllal jabb osztlyok

definilsra. Az sben szerepl tulajdonsgokat, vagy mveleteket a leszrmazottakban jra fel tudjuk hasznlni ismtelt definci nlkl is.
6. bra: rklds
Az rktsi mdok az egyes programrendszereknl tbbflekppen valsthatak meg. Minden objektumorientlt programrendszer lehetv teszi
az egyszeres rklst, ahol minden leszrmazott osztlynak egy s csakis
egy se lehet. Egyes rendszerek lehetv teszik a tbbszrs rklst is,
ekkor egy leszrmazott kt, vagy tbb sosztly leszrmazottja is lehet. A
tbbszrs rkldsnl is rvnyesl az rklsi szably, azaz minden
leszrmazott osztly rkli az sosztlyok adattagjait s metdusait. A
leszrmazott osztlyok objektumai (pldnyai) elrhetik a sajt, illetve az
sosztly mveleteit.
Programozsi szempontbl az egyes osztlyok definilsnl a keresd
az st mdszert alkalmazhatjuk. Azaz minden olyan mvelet, amely az
osztlyhierarchia egy adott szintjn tbb osztlyban is megjelenik, azt mr
az sosztlyban clszer definilni, hiszen gy minden leszrmazott rkli
Vissza
26
Programozs III.
Vissza
27
azt, gy a mveletet elg egyszer megadni. Az rklds ezen tulajdonsgainak kihasznlsa segt elfelejteni azt a hibs programozi gyakorlatot,
amikor a hasonl mveletek elvgzshez redundns kdot rnak.
2.4.1. Absztrakt osztlyok
Az objektumhierarchia tervezse sorn a konkrt programnyelvi megvalststl fggetlenl kialaktjuk a feladatot ler tpusdefincikat. Sok
esetben a programtervezs sorn szksgnk van egy kzs sre, amibl
kiindulva az sszes leszrmazott rtelmezhet. Teht egy olyan osztlyt
kell definilnunk, amely egysgbe foglalja, knnyen kezelhetv teszi a
leszrmazott osztlyhoz tartoz objektumokat. Ezek az osztlyok ltalban mg ltalnosak, sokszor csak az osztlyhierarchia szmra szl zenetek szablyait definiljk. (A hierarchia klnbz szintjhez kapcsold objektumokat gy azonos zenetekkel rhetjk el.) Ezeket az osztlyokat absztrakt osztlyoknak nevezzk.
Az absztrakt osztlyok kizrlag rktsi cllal ltrehozott osztlyok. Az
absztrakt osztlyokhoz nem rendelhetek objektumok, nem
pldnyosthatak.
Az absztrakt osztlyok megvalstsban gyakran hinyoznak az adattagok, s sokszor tallkozunk res metdusokkal, melyek csak egy egysges
interfszt, a leszrmazott objektumok szmra kldhet azonos zeneteket definiljk.
Az absztrakt metdusok mindegyike res trzs virtulis metdus. Ezeket
az absztrakt metdusokat majd a leszrmazottak felldefiniljk, megvalstjk. Absztrakt metdus csak absztrakt osztlyban adhat meg.
Az absztrakt osztlyok nem pldnyosthatk, hiszen tartalmaznak olyan
mveleteket, amelyek mg definilatlanok.
Vissza
27
Programozs III.
Vissza
28
7. bra: Absztrakt osztlyok hasznlata

Az absztrakt osztlyok segtsgvel osztlyhierarchit is felpthetnk, de a
leszrmazott osztlyokat mindaddig absztraktnak kell tekinteni, mg az
sszes absztrakt metdust meg nem valstjk (nem adnak r konkrt defincit). Ennek megrtshez azonban meg kell ismerkednnk a polimorfizmus tulajdonsgaival.
Egy pldban egy olyan osztlyhierarchit szeretnnk megadni, amely a
matematikban megismert fggvnyek kezelst teszi lehetv. Az osztlyozs sorn megadhatjuk a konstans-, a lineris-, s a msodfok stb.
fggvnyeket. A fggvnyrtkek elrshez a matematikban ismert y(x)
alak zeneteket hasznlunk majd, ahol y(x) az x helyen felvett fggvnyrtket jelenti. A kzs zenetkldsnek az sszetettebb objektumorientlt programokban nagyon fontos szerepe lesz. Az egyes konkrt osztlyok kzs snek egy absztrakt Fggvny osztlyt definilunk, amelynek
csak egy absztrakt y metdusa lesz. A leszrmazottakban ezt az y metdust fogjuk rendre felldefinilni.
Vissza
28
Programozs III.
Vissza
29
2.4.2. Interfszek
Az absztrakci fogalmnl nhny pillanatot elidzve, egy fogalmat mg

tisztznunk kell. Az objektumorientlt modellezs sorn az absztrakci
egy magasabb szint megvalstsa lehetv teszi az olyan osztlyok (interfszek) definilst, amelyek mr konkrt objektumhoz kthet adattagot sem tartalmaznak, csupn azoknak az zeneteknek a formtumspecifikcijt adjk meg, amelyek majd csak ksbb, a leszrmazottakban fognak megjelenni. Az interfszek hasznlatval egy magas szint, a konkrt
megvalststl fggetlen felletet lehet a feladat szmra megadni. A tervezs fzisban az interfszek hasznlata nagyfok rugalmassgot, knny
mdosthatsgot nyjt. Az absztrakt osztlyokhoz hasonlan az interfszekben deklarlt mveleteket is a leszrmazottak valstjk meg.
2.5. Tbbalaksg
A tbbalaksg (polimorphism) szintn objektumorientlt alapfogalom.
Mivel ez a fogalom tbbfle jelentssel br, ezrt mlyebb vizsglatot ignyel. Elszr is meg kell klnbztetnnk a vltozk s a mveletek
tbbalaksgt.
A vltozk polimorfizmusa azt jelenti a dinamikus tpusokat tmogat nyelvekben (Smalltalk, PHP) hogy egy vltozt dinamikus tpusnak
is deklarlhatunk, a hagyomnyos statikus tpusok mellett. A dinamikus
tpus azt jelenti, hogy egy vltoz lettartama sorn ms-ms osztlyhoz
tartoz objektumokat is rtkl kaphat. Ezeknl a nyelveknl a felvzolt
megolds nagyon gyakori, m szmos, nehezen feltrhat hibalehetsget
rejt magban.
Vltozk tbbalaksga
A dinamikus tpust kzvetlenl nem tmogat nyelvekben is van lehetsgnk polimorfikus vltozk deklarlsra, az rklds egyik hasznos
tulajdonsgnak kihasznlsval. Az automatikus tpuskonverzit, illetve a
tpusknyszertst kihasznlva egy leszrmazott osztly pldnyait az sosztly egy elfordulsnak is tekinthetjk (bizonyos megszortsokkal) gy
egy sosztlyknt deklarlt vltoz egy leszrmazott objektumot is felvehet rtkl.
Vissza
29
Programozs III.
Vissza
30
Egy vltoz, lettartalma alatt az implementl nyelv szablyai szerint

ms-ms, vele rklsi viszonyban ll osztlybeli objektumot is rtkl
vehet fel.
A mveletek tbbalaksga
Sokkal gyakoribb s elterjedtebb a mveletek tbbalaksgnak hasznlata. A feladatmegoldsok sorn sokszor kell hasonl mveleteket elvgezni.
Az objektumorientlt terminolgia szerint az egyes objektumoknak hasonl zeneteket kell kldeni. A mveletek polimorfizmust ltalban ktflekppen rtelmezzk.
Felltlts
Az els rtelmezs szerint egy objektum a hozz rkez azonos zeneteket az zenetben rkez adat tpusa (osztlya) szerint msknt hajtja vgre.
Ezt a megoldst felltltsnek nevezzk (overloading). Az egyes programozsi nyelvek lehetv teszik az azonos nev, m eltr
paramterezettsg metdusok definilst egy osztlyon bell. Itt a metdus neve mellett a metdusok szignatrja (paramterek tpusa s szma) is hozztartozik az egyrtelm azonostshoz. Ezutn minden egyes
metdushvs rvnyes lesz, amely megfeleltethet valamelyik felltlttt
metdusnak. A hvs pedig az aktulis paramterlista alapjn mr fordtsi idben ellenrizhet, majd a futs sorn vgrehajthat.
Egy objektum egy-egy zenetre tbbflekppen reaglhat. A felltlttt
metdusok (overload) segtsgvel a hasonl feladatokat azonos nvvel
illethetjk.
8. bra: Felltlttt metdusok egy osztlyban
Vissza
30
Programozs III.
Vissza
31
Felldefinils
A tbbalak mveletek msik csoportja a mveletek felldefinilsa
(overriding). Az rkls tulajdonsgt gy definiltuk, hogy a leszrmazott
osztly rkli az sosztly minden mvelett is. Ahol az sosztly mveletei hasznlhatk, ott a leszrmazott mveletek is felhasznlhatk lesznek.
Azonban az rklst sokszor azrt hasznljuk, hogy a leszrmazott osztlyt specializljuk, mert a leszrmazottak egy-egy mveletet mr msknt
hajtanak vgre. Egy osztly akkor definil fell egy metdust, ha az rklsi lncban megtallhat az adott metdus, gy azt teljes mrtkben rkln, de az adott osztly ugyanarra a metdusra sajt defincit ad.
Egy objektum attl fggen, hogy az osztlyhierarchia melyik szintjn
lev osztly pldnya, egy-egy zenetet mskpp hajt vgre. A metdusok
felldefinilsa (override) ezt teszi lehetv.
9. bra: Felldefinilt metdusok az osztlyhierarchiban

Ha feladatunk egy olyan program elksztse, amely hrom klnbz
tpusba sorolhat adatot trol veremszerkezetben, akkor strukturlt mdon a hrom verem szmra minden egyes mvelethez hrom-hrom eltr nev szubrutint kell rni. Az objektumorientlt szemllet szerint pedig
egyszerbb azonos zenetknt azonos nev, felltlttt metdusknt
definilni a mveleteket, amelyeket a tbbalaksg tulajdonsgnak kihasznlsval hatkonyan rhetnk el. A polimorfizmus hatkony kihasz-
Vissza
31
Programozs III.
Vissza
32
nlsa tlthatbb s kevsb szertegaz programozsi modellek ptst

teszi lehetv.
2.5.1. A futs alatti kts
Az egyes programozsi nyelvek ktfle zenet szerepkrt definilnak. Beszlhetnk statikus s dinamikus mveletekrl. A hagyomnyos programozsi nyelvekben statikus kts szubrutinokkal tallkozunk. Ez azt
jelenti, hogy az adott fordtprogram mr a fordts sorn (fordtsi idben) a szubrutin kapcsolsi cmt egyrtelmen meghatrozza (early
binding korai kts). gy egy adott nev szubrutin hvsa egyrtelm, a
hagyomnyos programozsi nyelvek nem lennnek alkalmasak arra, hogy
hatkonyan hasznljk ki a mveletek felldefinilst, illetve felltltst,
vagyis azt, hogy egy objektum mdostott metdusait elrjk. (A statikus
kts metdusokat az objektumorientlt programozsban osztlymetdusnak nevezik.)
Az objektumorientlt szemllet viszont ms megoldsokat vr, hiszen
az egyes objektumokhoz szorosan hozz kell rendelni az egyes mveleteket, teht olyan megoldst kell adni, amely futsi idben kpes az azonos
zeneteket legyen az egy felltlttt, vagy felldefinilt metdus hvsa
egyrtelmv tenni. Ehhez a megoldshoz a mveletek dinamikus sszekapcsolsa szksges.
A tbbalaksg kzs tulajdonsga, hogy a mveletek azonos nvvel hvhatk, m a vgrehajtskor a futs alatti kts, vagy ksi kts (late
binding, runtime binding) segtsgvel vlik egyrtelmv, hogy egy objektum egy zenetre melyik mveletvel reagl.
Tekintsk azt az esetet, amikor statikus hozzrendelssel definilva
egy osztlyban (tovbbiakban sosztly) definiljuk az A s B metdust,
ahol az A metdus a B-t hvja. rklssel ltrehozunk egy leszrmazott
osztlyt. Az rkls hatsra a leszrmazott is rendelkezik mind az A,
mind a B metdussal. A leszrmazott osztlyban a B metdust felldefiniljuk. Ha az sosztlyt pldnyostjuk, s a ltrejv pldnyt felkrjk,
hogy hajtsa vgre az A mveletet, akkor az elkezdi az sosztly A mvelett vgrehajtani, amely az sosztly B metdust hvja meg, majd az abban
definilt mveleteket vgrehajtja. Ez eddig hibtlanul mkdtt. Ha azonban a leszrmazott osztly egy pldnyval kvnjuk ezt a fenti mveletet
Vissza
32
Programozs III.
Vissza
33
vgrehajtani, akkor kudarcot vallunk. Hiszen a leszrmazott osztly pldnya (ha felkrjk az A mvelet vgrehajtsra) mivel a sajt osztlyban
nem tall A metdust, gy az rklsi lncon visszafel haladva megtallja
s vgrehajtja az sosztly A metdust. Az sosztly A metdusa pedig a
B metdust hvja meg. s itt trtnik a hiba, hiszen a statikus szerepek
miatt az sosztly csak a sajt metdusait ismeri, a vezrls nem tallja
meg a leszrmazott pldnyhoz tartoz felldefinilt B metdust, gy azt
az sosztlybl hvja. A leszrmazott pldnyhoz viszont a felldefinilt B
mveletet kellett volna elvgezni.
A dinamikus sszekapcsolst az egyes programnyelvekben eltren vgzik,
de vzlatosan a kvetkez szempontok szerint jrnak el:
Azokat a mveleteket, amelyeknl ki szeretnnk hasznlni a tbbalaksgot, virtulis mveletnek kell definilni.
Ha egy mveletet egy rklsi gban virtulisnak minstettnk, akkor
annak az sszes leszrmazottjban is virtulisnak kell lennie. A virtulis
metdusok kezelshez minden osztlyhoz az n. virtulis metdus
tblkat (VMT) rendelnek hozz. A VMT nem ms, mint az egyes osztlyhoz rendelt mind az sosztlybl szrmaz, mind a felldefinilt,
ill. felltlttt metdusok cmeit tartalmaz adatstruktra.
ltalnosan kijelenthet, hogy minden definilt osztlyhoz (amely
hasznl virtulis metdusokat) tartozik egy VMT, amelyet a pldnyostskor hozz kell rendelni az j objektumhoz.
Ezt a mveletet a tovbbiakban konstrukci nvvel illetjk.
A dinamikusan sszekapcsolt tbbalak vltoz- s metdushasznlat sorn nagyon fontos szempont az objektumok tervezett lettartamuk vgn
val teljes memria-felszabadts. A helyes programtervezshez hozztartozik a munka utni rendraks. Itt a konstrukcival ellenttes irny mveletet kell vgrehajtanunk, melyet destruktornak hv a szakirodalom.
A VMT kezelst az egyes programozsi krnyezetek mind msknt
valstjk meg, mkdst elrejtik a programoz ell. A hagyomnyos
hibrid programrendszereknl (Object Pascal, Delphi, C++) a virtual
kulcsszval hozhatunk ltre dinamikusan sszekapcsolt metdusokat, a
tisztn objektumorientlt nyelveknl (Smalltalk, Eiffel, Java) minden metdus alaprtelmezs szerint virtulis.
Vissza
33
Programozs III.
Vissza
34
2.6. Osztlyok s objektumok egyttmkdse,

kapcsolatai
A vals vilg modellezsnl az objektumok osztlyozsa s az osztlyok
hierarchikus felptse szmos feladatra nyjt megoldst. Az egyszerbb
feladatok modelljei utn egy vals problma megoldsakor rjvnk, hogy
az osztlyok kztt nemcsak hierarchikus kapcsolatokat pthetnk, hanem egymstl gykeresen eltr osztlyok kztt kell megteremtennk
valamilyen kommunikcit gy, hogy az objektumorientlt alapfogalmakat
ne srtsk meg.
Az objektumoknak valamilyen kapcsolatban kell llniuk egymssal, ha
kommuniklni szeretnnek egymssal. A kapcsolatokat rtelmezhetjk
konkrt objektumok kztt, vagy ltalnostva az osztlyok kztt. Az
osztlyok kztti kapcsolatok esetn a kapcsolatok is termszetesen ltalnos rtelmet nyernek.
Az objektumok kommunikcijt kt nagy csoportba: ismertsgi, illetve tartalmazsi kapcsolatba sorolhatjuk. Az objektumok illetve az osztlyok kztti kapcsolatok s a kommunikci brzolshoz az UML objektum- s osztlydiagramjait hasznljuk.
2.6.1. Ismertsgi kapcsolat
Kt objektum abban az esetben van ismertsgi kapcsolatban (asszocici),

ha mindkett egymstl fggetlenl ltezik, s legalbb az egyik ismeri,
vagy hasznlja a msikat. A tartalmaz fl valamilyen mutatn, vagy referencin keresztl ri el a msik objektumot. Az ismertsgi kapcsolatban
ll objektumok zenetet kldhetnek egymsnak. Amennyiben a program
lettartama sorn egyes, a kapcsolatban szerepl, hivatkozott objektumokra mr nincsen szksg, akkor az objektumok megszntethetek, de figyelni kell arra, hogy az objektum megszntetskor a kapcsolatot is meg
kell szntetni.
10. bra: Ismertsgi kapcsolat
Vissza
34
Programozs III.
Vissza
35
2.6.2. Tartalmazsi kapcsolat
A tartalmazsi kapcsolat egsz-rsz kapcsolat esetn kt objektum

nemcsak ismeri egymst, hanem az egyik objektum fizikailag is tartalmazza
a msikat. Msknt fogalmazva az sszetett objektum rsze egy msik, n.
rszobjektum. A tartalmazsi kapcsolatokat tovbbi kt rszre bonthatjuk.
Gyenge tartalmazs (aggregci) esetn a rszobjektum az sszetett
objektumtl fggetlenl is ltezik. Gyenge tartalmazs figyelhet meg egy
raktr s a benne raktrozott rucikkek kztt, hiszen az rucikkek a raktrtl fggetlenl lteznek, felhasznlhatak.
Ers tartalmazs (kompozci) esetn a rszobjektum nllan nem
fordul el. Egy gpjrm osztly s a hozztartoz alkatrszek kztt ers
tartalmazsi kapcsolat van, hiszen az alkatrszek nmagukban nem alkotnak mkdkpes jrmvet.
A tartalmazsi kapcsolatot az UML-jells szerint az sszetett objektum osztlytl egy rombuszbl kiindul nyl jelli. Gyenge tartalmazs
esetn res, ers tartalmazs esetn teli rombuszt rajzolunk.
11. bra: Tartalmazsi kapcsolatok

2.7. Kontner osztlyok
Gyakran szksgnk van olyan osztlyokra, amelyek gyenge tartalmazsi
kapcsolattal sok, a program futsi ideje alatt vltoz szm akr egymstl klnbz osztlyba tartoz objektumot tartalmaznak.
Amg az objektumok csak 1:1, vagy 1:N kapcsolatban llnak ahol N
rtke konstans addig a hagyomnyos ismertsgi, vagy tartalmazsi kapcsolattal is dolgozhatunk. Ha tbb objektumot 1:* kapcsolat kt ssze
vagyis a program tervezsekor mg ismeretlen a szmossg, vagy konstans
rtkkel nem korltozhat akkor n. kontner objektumokat haszn-
Vissza
35
Programozs III.
Vissza
36
lunk. A kontner objektumokat definil osztlyokat sszefoglal nvvel

kontnereknek nevezzk.
A kontner osztlyokbl pldnyostott objektumok szerepe s clja,
hogy a bennk elhelyezett objektumokat kezelje, s adatkarbantart mveleteket vgezzen (beszrs, trls, rendezs, keress stb.). A kontner osztlyok s az ezeket absztrakt szinten definil interfszek hasznlatval
egy magas szint, a tervezsi s a megvalstsi szinteket jl elklnthet
eszkzrendszer ll a programoz rendelkezsre. A kontner osztlyok
interfszeinek definilsakor megadhat a kontner szablyrendszere, s
az zenetek egysgesthetk. Az egysgests azrt clszer, mert a gyakran hasznlt adatkezel mveletek,
Az olyan fejlett adatstruktrk hasznlathoz, mint a dinamikus tmbk, a verem, az egyszer s sszetett listk, a binris s tbbg fk, a
kupac, a halmaz, az asszociatv tmbk, a hasttblk, grfok stb. hasznlathoz elengedhetetlen a kontner osztlyok hasznlata. [Marton02,
Cormen01]
12. bra: Egy kontner osztly lehetsges megvalstsa

A kontner osztlyok szerept egy nagyon egyszer pldval szeretnm
bemutatni. Egy cg A vrosbl vaston szeretn a termkeit elszlltani
B vrosba. Ebben az esetben a kontner objektum szerept maga a vasti szerelvny tlti be, hiszen az ru berakodsa a vagonokba, az utazs,
majd a kirakods mind jl definilt s a termkektl elklnl magas
szint mvelet. A kontner fggetlen a szlltott termktl.
Vissza
36
Programozs III.
Vissza
37
2.8. Komponensek
Az objektumorientlt programtervezs sorn clszer a logikailag sszetartoz s egyttmkd osztlyokat csoportostani. Az gy elll csomagok, vagy ms terminolgia szerint komponensek jrafelhasznlhat, ms
programokba beilleszthet kdot alkotnak. A komponensek egymsba
gyazhatak, gy tetszleges mlysg komponens-struktra pthet fel.
Komponens: egy adott rendszer rszt kpez klnll, ltalnos cl
osztlygyjtemny (amely nmagban is zrt egysget kpez), de ms
programokba is szabadon bepthet.
Az elksztett komponensek szabvnyos, sszeszerkesztett, tesztelt ptelemek. Az egyes objektumorientlt programnyelvekben definilt komponensek hasznlata hatkonyabb s szabvnyosabb fejlesztst tesz lehetv.
Ilyen komponens lehet pldul: egy adott adatbziskezel rendszer szabvnyos elrst, vagy ppen egy grafikus vezrlelemet megvalst komponens.
2.9. Krdsek
Melyek a legfbb klnbsgek egy osztly s egy objektum kztt?

Miket tartalmaz egy osztly?
Mit neveznk egysgbezrsnak?
Mit jelent az adatrejts elve?
Milyen fbb hozzfrsi kategrikat definil az objektumorientlt
szemllet?
Mi a klnbsg az adattag s a metdus kztt?
Mit jelent az rklds?
Mi a tbbalaksg?
Mit jelent a futsidej (ksi) kts fogalma?
Mikor neveznk egy osztlyt absztraktnak?
Mirt nem pldnyosthat egy absztrakt osztly?
Mit rtnk objektumok egyttmkdsi kapcsolatn?
Mi a klnbsg a gyenge s az ers tartalmazsi kapcsolat kztt?
Mi clt szolglnak a kontner osztlyok?
Vissza
37
Programozs III.
Vissza
38
2.10. Feladatok
Tervezze meg az albbi, egymstl fggetlen osztlyokat, s rajzolja meg
az UML osztlydiagramokat! (Lehetleg gyjtse ssze a legjellemzbb
adatokat s azokat a mveletet, melyek az adott osztlyhoz tartoz pldnyokon elvgezhetk.):
Alkalmazott
rucikk
Gpjrm
Dobkocka
bresztra
Bejrati ajt
Lzernyomtat
Tintasugaras nyomtat
MP3-zeneszm
Fnykp
Hibajelensg
Vissza
38
Programozs III.
A Java technolgirl kzelebbrl

Vissza
39
3. A Java technolgirl kzelebbrl

3.1. Keretrendszerek
A Java fejlesztsekhez mindig valamilyen fejleszt krnyezetet hasznlunk,
legyen az a legegyszerbb parancssori fordt, vagy a legmodernebb grafikus fejlesztkrnyezet.
A Sun Microsystems ltal kifejlesztett szabvnyos krnyezet a JDK
(Java Development Kit). Ez tartalmazza a fejlesztshez alapveten szksges rszeket (fordt, nyomkvet, futtat krnyezet s egyb segdprogramok), illetve a szabvnyos Java osztlyknyvtrakat (tovbbiakban
API Application Programming Interface) amely jelenleg kb. 6500 klnbz osztlyt s interfsz hiearchikus felptst jelenti.
Az API magnak a Java nyelvnek a teljes nylt forrskd
osztlyknytr-struktrjt tartalmazza. (A teleptett rendszer futtat krnyezetben a tmrtett /jre/lib/rt.jar fjlban, illetve a forrsa az
src.zip fjlban tallhat.) A tervezsnl a logikailag knnyen tlthat,
hibamentes s knnyen felhasznlhat osztlyhierarchia megalkotst tztk ki clul. A programozk rszre rengeteg, jl elklnl osztlyt adnak
a kezkbe feladataik elvgzsre. Ezek az osztlyok (kb. 6500 db) azonban
csak jl felptett struktra alapjn lesznek tlthatk s hatkonyan felhasznlhatk.
A forrskdok szerkesztshez olyan szvegszerkesztt clszer hasznlni, amely az egyes nyelvi jellegzetessgeket felismeri, tlthat s kiemelseket hasznl, emellett gyors, s kis helyet foglal. (SciTe, WsCite,
TextPad, Emacs, JEdit, UltraEdit stb.) [4]
Az egyes cgek ltal kifejlesztett integrlt krnyezetek nagyban segtik
a programozsi munkt. Tartalmaznak tbbek kztt szvegszerkesztt,
fordt, futtat, nyomkvet eszkzt s beptett sgt. A legmodernebb
(fizets) krnyezetek ezeken fell tartalmaznak beptett adatbzis-, web-,
alkalmazs-, portl- s azonnali zenetklds szervereket a hatkony csapatmunka elsegtsre.
A legelterjedtebb keretrendszerek (IDE: Integrated Development
Engine), a teljessg ignye nlkl: Sun-JavaStudio, Eclipse, NetBeans,
Borland-JBuilder, IBM-Websphere, JCreator, Oracle-JDeveloper.
Vissza
39
Programozs III.
Vissza
40
3.2. Nyelvi alapelemek

3.2.1. Kulcsszavak s azonostk
A forrskdban a nyelvi elemeket kt csoportra bontjuk: kulcsszavak s

azonostk. A Java kulcsszavai olyan szavak, amelyek a Java programok
szerkezett s vezrlst meghatrozzk, s amelyeket azonostkknt
nem hasznlhatunk fel.
abstract
boolean
break
byte
case
catch
char
class
const
continue
default
do
double
else
extends
final
finally
float
for
goto
if
implements
import
instanceof
int
interface
long
native
new
package
private
protected
public
return
short
static
super
switch
synchronized
this
throw
throws
transient
try
void
volatile
while
1. tblzat: A Java kulcsszavai

A kulcsszavak kzl a goto s a const a nyelvben nem rtelmezett kulcssz, de foglalt minstst kapott, gy azokat programjainkban nem hasznlhatjuk azonostknt. A nyelv alaprtkeit jelz literlokkal sem kpezhetnk azonostkat (true, false, null).
Az azonostkpzs szablya nagyon egyszer. Egy azonostval egy
elemet (osztly, adattag, metdus, vltoz) azonostunk, s valamilyen
betvel kezdd, s betvel vagy szmjegyekkel folytatd karaktersorozatknt adunk meg. Az azonostk tartalmazhatnak _ karaktert is.
Mivel a Java a unicode szabvny szerinti kdolst hasznl (UTF-8), az
azonostkban megengedettek az kezetes karakterek is, azonban bizonyos esetekben nem hasznlhatak platformfggetlenl. (A csomagok,
osztlyok s a fjlok nevei nem mindenhol kpezhetek le azonos mdon
az adott opercis rendszerek szablyai szerint.)
Az azonostk kpzsnl azt is figyelembe kell venni, hogy a Java
nyelv kis- s nagybet rzkeny. Az ajnlsok szerint a hosszabb nev
Vissza
40
Programozs III.
Vissza
41
azonostknl a msodik sztl kezdve az els betket nagybetvel rjuk,

javtva az olvashatsgot:
szletsiDtum, nagyonHossznevAzonost.
Megjegyzs: Az azonostkpzs ajnlott szablyait a 12. fejezetben vagy a

[6]-ban talljuk meg rszletesebben.
3.2.2. Adattpusok
Mieltt elmlylnnk a Java nyelv osztlyainak vizsglatban, tisztban kell

lennnk a Java nyelv tpuskpzsi szablyaival. A nyelv a kvetkez alaptpusokkal dolgozik:
Alaptpus Csomagol rtkkszlet
osztly
boolean
Boolean
true, false
Lers, mret
logikai tpus (1 bjt)
char
Character
65535 db: \u0000\uffff unicode karakter (2 bjt)
byte
Integer
-128127
eljeles egsz szm (1 bjt)
short
Integer
-3276832767
int
Integer
-2147483648 2147483647 eljeles egsz szm (4 bjt)
long
Long
float
Float
-9223372036854775808
92233372036854775807
1.4 10-45 3.4 1038
double
Double
4.9 10-324 3.8 10308

lebegpontos vals szm
(4 bjt)
lebegpontos vals szm
(8 bjt)
2. tblzat: A Java alaptpusai (elemi tpusok)

Az alap-, vagy elemi tpusokhoz tartoz vltozk a C nyelvhez hasonlan adott tpushoz tartoz rtkeket trolnak. Az ilyen vltozk hasznlata megegyezik a C nyelv szablyaival (deklarci, kezdrtk ads stb.).
A tblzat msodik oszlopban lthat csomagol osztly kifejezs azt
jelenti, hogy ezeket az alaptpus vltozkat egy, a tpust ler osztly objektumaknt is felfoghatjuk, s az objektumokkal azonos mdon kezelhetjk ket (bvebben lsd: 3.2.11. fejezet).
Vissza
41
Programozs III.
Vissza
42
13. bra: A Java adattpusai

A Java adattpusai gpfggetlenek, vagyis minden architektrn, ill. opercis rendszeren azonos formban, azonos brzolsi tartomnnyal lesznek
trolva, feldolgozva.
A C nyelvbl ismert void kulcssz a Java nyelvben nem tpust jell, hanem csupn azt, hogy egy metdus nem ad vissza rtket a hv
rutinnak.
A vltozk deklarcija sorn legalbb a vltoz tpusnak, s azonostjnak szerepelni kell. Tbb vltoznevet vesszvel vlasztunk el, illetve
a deklarci sorn kezdrtket is rendelhetnk a vltozkhoz. Ebben az
esetben a vltoz defincis deklarcijrl beszlnk.
int x;
int y, z;
short r=4, p=0;
Az osztlyok adattagjai automatikus kezdrtket kapnak (amennyiben

nem rendeltnk hozzjuk semmit). Az automatikus rtkek a kvetkezk:
boolean
char
byte, short, int, long
float, double
objektum referencia
false
\u0000
0
0.0
null
Az egyes metdusok loklis vltozi azonban hatrozatlanok lesznek, az

inicializlsrl a programoznak kell gondoskodnia!
A Java nyelv objektumait a referencia tpus vltozkkal rjk el. Az
osztlyok pldnyostsa sorn valahol a memriban helyet foglalunk az
Vissza
42
Programozs III.

Vissza
43
objektumnak s egy vltozval referencia ezt a memriaterletet elrhetjk.

Teglalap t2 = new Teglalap (2,5);
Azonban nem szabad sszekevernnk referencit a C nyelv mutat tpusval. Ott a mutat egy adott memriacmre val hivatkozs, amelynek
adattartalmt indirekcival rhetjk el. A Java nyelvben azonban a referencia klnbzik a hagyomnyos mutatktl abban, hogy a hozzrendels utn ezt a cmet azonnal elrejti a programoz ell, s automatikusan
az egsz lefoglalt objektumot jelenti. A pldnyosts sorn teht a new
opertor ltal ellltott referencit hozzrendeli a megfelel tpus azonosthoz (t2). Ezutn az ezzel az azonostval hivatkozott objektum nyilvnos tagjai hivatkozhatk.
Egy specilis referencia rtk a null, amely rtkl adhat minden referencia tpus vltoznak. A null olyan referencia, amely nem mutat
egyetlen objektumra sem. A null rtk referencikon keresztl nem
lehet egyetlen objektumra sem hivatkozni, metdust hvni (ha mgis megtennnk futsi idej kivtel esemny keletkezik: NullPointerException;
a kivtelkezelsrl bvebben a 7. fejezetben lesz sz).
Abban az esetben, ha egy objektumra mr nincsen tbb szksgnk,
clszer a lefoglalt memrit felszabadtani. Sok programozsi nyelvben ezt
a programoznak kell kezdemnyeznie destruktor hvssal. A Java nyelv
azonban nem hasznl destruktort, hanem az n. szemtgyjt mechanizmussal (garbage collector) sznteti meg a nem hasznlt objektumokat.
A szemtgyjts a virtulis gp rsze, mkdse elve a kvetkez:
minden egyes objektumot addig tekint hasznlatban lvnek, amg arra
valamilyen referencia hivatkozik. Amint ezt a hivatkozst megszntetjk,
az objektum mr a programbl elrhetetlen hiszen megsznt az sszekapcsols a trterletet a szemtgyjt felszabadtja.
3.2.3. Megjegyzsek
A forrskdban fontos szerep jut a megjegyzseknek. Ezeket a rszeket a

fordtprogram figyelmen kvl hagyja, csak a fejlesztk szmra az
elemzs megknnytsre hordoznak informcit a forrskd mkdsrl. A forrsban minden olyan helyen lehet megjegyzs, ahol az a program szintaktikjt, ill. szemantikjt nem befolysolja.
Vissza
43
Programozs III.

Vissza
44
A Java hrom fajta megjegyzst ismer.

A legegyszerbb a ketts trtjel: //. A jel utn kvetkez karaktersorozat a sor vgig megjegyzsnek minsl.
A msodik a C nyelvbl ismert /* */ zrjelpr, ahol a kzrezrt rsz
szintn nem kerl fordtsra. Ez a megjegyzs tbb sorbl is llhat.
A msodik tpus specilis vltozata a /** */alak, n. dokumentcis
megjegyzs. Ezeket a dokumentcis megjegyzseket egy definilt
elem (osztly, adattag, metdus, csomag) eltti sorokban hasznljuk.
Ezeknek a megjegyzseknek klnleges jelentsge van, hiszen a Java
fejlesztkrnyezet javadoc programjval html formtum dokumentcit generlhatunk. (A javadoc program lerst lsd a 13.2. fejezetben)
Megjegyzs: Maga a Java API dokumentcija is ezzel a segdprogrammal
kszlt.
3.2.4. Osztlyok
A Java nyelvben az osztly az brzols alapegysge. Minden adatot, s

minden mveletet osztlyokon bell rtelmeznk. Mivel a nyelv megalkotsakor trekedtek a tisztn objektumorientlt kialaktsra, osztlyokon
kvl nem helyezhetnk el adatokat, utastsokat.
Minden osztly az elmleti megkzeltst kvetve kt logikailag klnvl rszre bonthat: adatokra s mveletekre. Az adatok (adattagok)
az egyes objektumok tulajdonsgainak trolsra, a mveletek (metdusok) pedig kizrlag ezeken az adatokon val mveletvgzsre szolglnak.
Az albbi pldban egy tglalapokat ler osztlyt definilunk. A tglalapot
az a s b oldalnak hosszsgval jellemezzk, s rtelmezzk a terlet s a
kerlet mveleteket.
Vissza
44
Programozs III.
public class Teglalap{

private double a;
private double b;

Vissza
45
//osztlydefinci
//adattagok
public Teglalap(double a_, double b_){

//konstruktor
a=a_; b=b_; }
public double kerulet(){
//metdusok, tagfggvnyek
return 2*(a+b); }
public double terulet(){
return a*b; }
}
A programban a Teglalap nev publikus osztlyt definiljuk, melynek

kt adattagja van. Az adattagok az adatrejts elve szerint privt minstsek lesznek.
Az a s b adattagok deklarcija utn a konstruktor mvelett fejtjk ki. A konstruktor arra szolgl, hogy a Teglalap osztlybl pldnyokat hozzunk ltre a ksbbiekben. A konstruktort minden esetben az osztly nevvel megegyez nev metdusknt definiljuk.
Figyeljk meg, hogy a konstruktor definilsakor nem adtunk meg
visszatrsi rtket, mivel a konstrukci eredmnye egy Teglalap tpus
objektum lesz. A konstruktor illetve a metdusok vgrehajthat utastsait kapcsos zrjelek kz rjuk. A metdusok definilsakor elszr a lthatsgot, a visszatrsi tpust, a metdus nevt, majd a formlis paramterlistt adjuk meg.
A Java nyelv nvadsi konvencija szerint az osztlyok neve nagybetvel, az adattagok, metdusok s egyb azonostk pedig minden esetben
kisbetvel kezddnek. Ennek betartsa javtja a programok s a forrskdok olvashatsgt, tlthatsgt.
Az osztlyok definilshoz szorosan hozztartozik, hogy egy osztlyt
egy, az osztly nevvel azonos nev, .java kiterjeszts fjlban adunk
meg, kis- s nagybet helyesen. Teht a fenti pldt a Teglalap.java forrsfjlban helyezzk el.
Megjegyzs: Egyes opercis rendszerek nem konvertljk helyesen a
unicode karaktereket, gy az oszlynevek klnbzni fognak a trolt fjlnevektl. Ekkor az elksztett programok nem lesznek hordozhatk, ms
rendszereken bizonytalan a futtathatsguk. Ezrt az osztlyok nvadsnl kerljk az kezetes karaktereket, jllehet a nyelv szablyai ezt megengedik.
Vissza
45
Programozs III.
Vissza
46
A Teglalap osztly definilsval, majd fordtsval mr egy hasznlhat

osztlyt kaptunk. Mivel azonban az osztly csak egy tpust definil, mg
szksges az is, hogy pldnyostsuk. A pldnyosts sorn szletik meg
egy konkrt objektum, amely mr rendelkezni fog sajt memriaterlettel,
s az zeneteket is ennek a konkrt objektumnak kldhetjk.
A pldnyostshoz s a Teglalap osztly kiprblshoz egy j osztlyt definilunk. A Teszt osztly forrsfjljt (Teszt.java) ugyanabban a
knyvtrban helyezzk el, mind a tesztelni kvnt Teglalap.java forrsfjlt.
public class Teszt{
// A main metdus, a program belpsi pontja
public static void main(String args []){
// t1 objektum deklarcija
Teglalap t1;
// pldnyosts, konstruktor hvsa
t1 = new Teglalap(3,4);
//ugyanez tmrebben
Teglalap t2 = new Teglalap(2,5);
// A program trzse, az egyes objektumok elrse
System.out.println(A t1 kerlete: + t1.kerulet()
System.out.println(A t1 terlete: + t1.terulet()
System.out.println(A t2 kerlete: + t2.kerulet()
System.out.println(A t2 terlete: + t2.terulet()
);
);
);
);
}
}
A fenti pldban ltrehoztuk a Teszt osztlyt, amelybl a Teglalap tpus objektumokat el kvnjuk rni. A futtathatsghoz konzolos programok esetn egy main metdust kell definilnunk, amelynek trzsrszben megadjuk a program utastsait. (A main tbbi mdostjra mg ksbb visszatrnk.) A Teglalap tpus t1 objektumot a Teglalap osztly pldnyostsval keltjk letre.
A this kulcssz
A metdusok definilsakor gyakran hasznlt elem a this kulcssz. A
Java nyelvben a this tbb jelentst is takarhat.
A metdusokban szerepl this az aktulis objektumra val hivatkozst jelenti. Az egysgbezrtsg s az adatrejts elvben azt fogalmaztuk meg, hogy egy metdus az objektum sajt adatain dolgozik. Ezrt
Vissza
46
Programozs III.

Vissza
47
egy adattagra val hivatkozs minsts nlkl alaprtelmezs szerint az aktulis pldny vltozjt ri el. Ehhez az adott metdusnak
tudnia kell, hogy ppen melyik pldny adataival kell dolgoznia.
Ezt gy oldottk meg, hogy minden egyes metdus rendelkezik egy
rejtett, referencia tpus paramterrel, amely ppen az aktulis pldnyt
jelli. Ezt a paramtert minden egyes hvskor a vgrehajtand metdus megkapja. A this hasznlatval az osztly adattagjai akkor is elrhetek lesznek, ha a paramterbl rkez, vagy azonos nev loklis vltozk elfednk azokat (lsd lthatsgi szablyok).
A Teglalap osztly konstruktort gy is felrhatjuk:
public Teglalap(double a, double b){
this.a = a;
this.b = b;
}
Ahol this.a a pldny adattagjt, az a pedig az rkez paramtert jelenti.

A this tagfggvnyknt is rtelmezhet. Az 4.3. fejezetben rszletesen
lesz sz a konstruktorok felltltsrl, most csak annyit jegyznk
meg, hogy a this() hivatkozssal az osztlyban definilt konstruktort
rhetjk el.
3.2.5. Kifejezsek s opertorok
A kifejezsek alapveten kt clt szolglnak: egyrszt a mr ismert rtkekbl j rtkeket lltanak el, msrszt mellkhatsknt vltozsokat
eredmnyezhetnek. A kifejezsek rtknek meghatrozst kirtkelsnek
hvjuk. A kifejezsek operandusokbl (vltozk, konstansok), opertorokbl (mveleti jelek) s zrjelekbl llnak.
Az opertorok elhelyezkedse szerint az egyes mveletek lehetnek:
prefix az opertor az operandus eltt ll,
postfix az opertor az operandus utn ll, vagy
infix jelleg az opertor az operandusok kztt helyezkedik el.
Ezeken kvl a kifejezseket csoportosthatjuk operandusainak szma
alapjn is, gy beszlhetnk egyoperandus (unris) vagy ktoperandus
(binris) kifejezsekrl. A Java nyelv rklte a C nyelv egyetlen hromoperandus mvelett, a feltteles kifejezst is ( ? : ).
Vissza
47
Programozs III.
Vissza
48
A Java nyelvben a kirtkelsi sorrend egy gynevezett precedencia

tblzat alapjn meghatrozhat. Mivel a nyelv ersen tpusos, ezrt a
kifejezsekhez is egyrtelmen rendelhet tpus. A tpusok kztti tjrst
a tpuskonverzi teszi lehetv.
A nyelvben a vgrehajtsi sorrend (a kifejezs kirtkelse) a mveleti
jelek kztti precedencia szably alapjn kvetkezik.
Opertor
Megnevezs
[ ]
.
( )
tmb indexels
tagelrs pl: java.lang.Math.PI
zrjeles kifejezs
kif++ kif--
postfix opertorok
++kif --kif +kif kif prefix opertorok

! ~
logikai NEM, bitenknti NEM
new
(tpus)kif
pldnyosts
tpusknyszerts
* / %
+ -
aritmetikai mveletek
<<
>>
>>>
eltols balra, a legkisebb bit 0-t kap

eltols jobbra, s balrl a legmagasabb helyirtk
bit rtke kerl be
eltols jobbra, balrl 0 rkezik.
< > <= >=

instaceof
sszehasonltsok
az objektum pldnya-e az osztlynak
== !=
egyenlsg vizsglatok
&
bitenknti S
bitenknti kizr VAGY
bitenknti VAGY
&&
logikai S
||
logikai VAGY
? :
feltteles kifejezs
= += -= *= /= %=
hozzrendels, rtkads
>>= <<= >>>=

&= ^= |=
bit szint rtkadsok
3. tblzat: Mveletek precedencija
Vissza
48
Programozs III.

Vissza
49
3.2.6. Tpuskonverzi
A Java fordt a fordts sorn minden esetben megvizsglja, hogy az

egyes kifejezsek sszeegyeztethet tpusokbl llnak-e, pontosabban automatikus konverzival mdostva azonos tpus kifejezsekk konvertlhatk-e a vizsglt kifejezsek. A nyelv hrom fajta konverzit nyjt a
programozk szmra:
Automatikus konverzi: Az automatikus konverzi minden esetben
vgrehajtsra kerl, amikor hozzrendels, vagy paramtertads trtnik. Abban az esetben, ha a fogad oldal tartalmazza az rkez adatot ler adattartomnyt, az rkez adatot erre a bvebb adattpusra
alaktja a fordt. Ha a konvertls nem hajthat vgre, a fordt hibt
jelez. Nhny esetben azonban az automatikus konverzi rtkvesztssel jrhat, ezt a fordtprogram figyelmeztet zenettel jelzi.
byte b=1; short s; int i; long l; float f; double d;
s = b;
// bvebb rtelmezsi tartomny
i = s; l = i;
// bvts, automatikus konverzi
f = l;
// adatveszts elfordulhat!
d = f;
// bvts, automatikus konverzi
Objektumok referencii kztt is ltezik automatikus konverzi. Egy

adott osztly objektum referencija felhasznlhat mindenhol, ahol valamilyen sosztly tpus azonostt vrunk.
Sikidom alakzat = new Teglalap(5,6);
Explicit konverzi: Amennyiben az automatikus konverzi nem

elgsges, nem egyrtelm, vagy informciveszts lphet fel, akkor
lehetsgnk nylik explicit tpuskonverzit alkalmazni.
double d = 12.8;
int i = (int)d;
// i rtke 12 lesz!
short s = (short) i;
stpus vltoznv = (stpus)leszrmazottTpusObjektum;
Szvegkonverzi: Ha egy kifejezsben String tpusra van szksg,

de a kifejezs nem ilyen, akkor a fordt automatikusan szveges adatokk konvertlja azt. A konverzit az adott objektum toString()
metdus hvsval ri el. (Mivel a Java nyelvben minden osztly kzs
se az Object osztly, az abban definilt toString() metdus a leszrmazottakban elrhet, felldefinilhat.)
Vissza
49
Programozs III.
Vissza
50
Abban az esetben, ha a kifejezsben nem objektumok, hanem csak

elemi tpusok szerepelnek, akkor a java.lang csomag megfelel osztlyaiban definilt toString() mveletekkel trtnik meg az automatikus konverzi, azaz a kifejezseket legvgl karakterekk konvertlja,
majd a karaktereket sszefzve String-knt felhasznlja.
int a=4;
System.out.println(23);
// eredmny: 23
System.out.println(23+a);
// eredmny: 234
System.out.println((23+a)); // eredmny: 27
3.2.7. Hozzfrsi kategrik
Az objektumorientlt alapelvek durva megsrtse lenne, ha egy osztly

adattagjait brmely ms osztlybl elrhetnnk. Nagy programok esetn
pedig tnyleg bonyolultt vlna, hogy minden osztlyrl nyilvntartsuk,
mely msik osztlyokkal tart fenn adat szint kapcsolatot (esetleg olyanokkal is, amelyekkel nem is volt a tervez szndkban). Kt, vagy hrom osztly esetn, programozsi szempontbl termszetesen egyszerbb
megolds lenne az adattagok direkt elrse, de az adatabsztrakcis s az
objektumorientlt elvek az adatrejts minden esetben val szigor hasznlatt vrjk el a programoztl.
A Java nyelv ngy hozzfrsi kategrit definil. Az adattag-, metdus- s osztlyhozzfrseket a nyelv rszt kpz mdost kulcsszavakkal hasznljuk.
Nyilvnos tagok (public): Ahhoz, hogy egymstl teljesen fggetlen
osztlyok pldnyai is ismertsgi kapcsolatba kerlhessenek, szksges
a mindenki ltal hozzfrhet tagok definilsa is. Nyilvnos minstst osztlyok s az ezen osztlyokon belli metdusok kaphatnak.
(Adattagokat az adatrejts fent vzolt elmlete szerint nem definilunk
nyilvnos minstssel, jllehet megtehetnnk. Egyetlen kivtel van,
amikor egy adattagot nyilvnossgra hozunk: a konstans rtkek. A Java nyelv a konstans rtkeket static final minstssel defininilja,
ezen adattagok rtke futs sorn nem vltozhat. Pldul a rtkt
java.lang.Math.PI-vel rhetjk el.)
Csomag szint tagok: Amennyiben egy osztlyt, vagy az osztly egy
adattagjt, metdust nem soroljuk egyetlen ms kategriba sem
(nem rjuk ki a private, protected, public mdostkat a definilskor),
akkor az azonos csomagban (azonos knyvtrban tallhat fjlok) elhelyezked osztlyok ezeket a tagokat szabadon elrhetik. A csomagon
Vissza
50
Programozs III.

Vissza
51
kvl elhelyezked osztlyokbl azonban mr elrhetetlenek lesznek. A

ksbbiekben ltni fogjuk, hogy a Java nyelv nagyon sokat hasznlja a
csomagokat, s a logikusan felptett osztlyhierarchikat. Egy csomagba ltalban az egymssal szorosan egyttmkd osztlyok kerlnek, amelyek ezt a hozzfrsi kategrit hatkonyan hasznljk ki.
Vdett tagok (protected): Ezt a kategrit nevezik mg a leszrmazottakban hozzfrhet tagok csoportjnak is. A vdett kategria a csomagszint, flnyilvnos kategria kiterjesztse. A vdett tagokhoz
hozzfrhetnek az azonos csomagban (azonos knyvtr) elhelyezked
osztlyok. Ha egy A osztly egy vdett tagjhoz egy msik csomagbl
szrmaz B osztly szeretne hozzfrni, akkor ezt akkor teheti meg, ha
az osztlyok rklsi kapcsolatban llnak, vagyis a B az A osztly leszrmazottja. Mskpp fogalmazva: vdett minsts esetn az egyes
tagok az osztlyhierarchin bell lthatak, teht egy leszrmazottbl
elrhetjk az s vdett adattagjait, mg akkor is, ha a leszrmazottat
egy msik csomagban definiltk. (Egy vdett konstruktort egy ms
csomagba tartoz gyermek csak super() hvssal hvhat meg! )
Privt tagok (private): Az osztlyok minden olyan adattagjt s metdust privtt tesszk, amelyeket meg szeretnnk vdeni ms osztlyoktl vagy mkdsk mellkhatsaitl. Az gy minstett tagok csak
az osztlyon bell lthatk, hivatkozhatk. Vagyis ezeket az adattagokat csak ennek az osztlynak a metdusai, illetve konstruktora ri el. A
privt metdusok szintn csak az t definil osztly metdusaibl,
konstruktorbl rhetek el.
A pldnyok szintjn a tagelrs a kvetkez szably szerint zajlik: Egy
osztlyban definilt metdus elrheti az osztly minden pldnynak adattagjt, mg ha az privt minstst is kapott. Pl. egy pldnyra meghvott
metdus elrheti a paramterben rkez, ugyanolyan osztly pldny
privt adattagjait is, hiszen ekkor nem hagyjuk el az osztly hatskrt!
3.2.8. Vezrlsi szerkezetek
A Java a strukturlt programozshoz hasonlan az utastsokat sorrlsorra hajtja vgre. Azonban az objektumorientlt programokat is valahogyan vezrelni kell. Az ismert alapszerkezetek a Java nyelvbe is bekerltek,
az albbiakban ezekkel ismerkednk meg.
Vissza
51
Programozs III.

Vissza
52
Utastsok
Legelszr az utastsokkal foglalkozunk. Az utastsok alapveten kt
csoportba sorolhatk: kifejezs-utasts, s deklarcis utasts. Minden
utastst a ; karakterrel zrunk le. Minden utasts helyn llhat egy
blokk, amelyet utastsok sorozataknt { s } jelek kz rva hozunk ltre.
Egy blokkon bell ltrehozhatunk loklis vltozkat deklarcis utastssal. Minden loklis vltoz az t magba foglal blokk vgig ltezik.
Logikai kifejezs
A Java nyelvben a boolean tpus true s false konstanssal reprezentlja
a logikai rtkeket. A logikai kifejezsrl beszlnk akkor, ha a kifejezs
logikai rtkt a fordt minden esetben egyrtelmen meg tudja hatrozni
automatikus konverzikkal. A relcis s a logikai opertorok, illetve zrjelezs segtsgvel sszetett logikai kifejezseket is felpthetnk. Szmos
szerkezetben hasznlunk logikai kifejezseket.
a >= b+1
objektum != null
objektum instanceof Osztaly
Feltteles kifejezs
Egy adott elemi vltoznak, vagy objektumnak sokszor feltehet eldntend krds, melyre igen/nem vlaszt vrunk. A feltteles kifejezs egy, a
C nyelvbl ismert hromoperandus kifejezs:
felttel ? kifejezs-ha-igaz : kifejezs-ha-hamis
a > b ? a : b
//feltteles kifejezs
max = (a>=b)? a : b;
//rtkad kifejezsbe gyazva
A felttel egy logikai kifejezs, amely a felttel igazsga esetn a kifejezs-ha-igaz, klnben pedig a kifejezs-ha-hamis rtket szolgltatja a teljes kifejezs rtkeknt.
Elgazsok, szelekcik
Az if utastssal a programban kt-, vagy tbbirny elgazst hozhatunk
ltre, ahol a megadott feltteltl fggen hajtdik vgre a program egyik,
vagy msik ga. Az if utasts szerkezete a kvetkez:
if (felttel) utasts;
Vissza
52
Programozs III.

Vissza
53
Az if utasts felttel kifejezse a fentiekhez hasonl logikai kifejezs. Itt

is fordtsi idben trtnik ellenrzs arra, hogy a felttel kirtkelhet-e,
vagyis a benne szerepl kifejezs automatikus tpuskonverzival boolean
tpuss konvertlhat-e. Futs sorn, ha a felttel igaz, akkor az utastst,
vagy az utasts helyn ll blokkot a program vgrehajtja. Ezutn a program a kvetkez utastssal folytatja futst.
Az if utasts msodik alakja, amikor a programot feltteltl fggen
kt gra bontjuk. Ha a felttel igaz, akkor utasts_1, klnben az
esle-g, vagyis az utasts_2 kerl vgrehajtsra.
if (felttel) {
utasts_1;
}
else {
utasts_2;
}
Megjegyzs: A Java kdolsi konvencik rtelmben (lsd: 206. oldal) az

egyrtelmsg kedvrt a vezrlsi szerkezetekben mr egyetlen utasts
hasznlata esetn is kerlni kell a blokkzrjelek nlkli formt (a kapcsos
zrjeleket ki kell rni)!
Amennyiben a programot gy szeretnnk vezrelni, hogy ne csak kett,
hanem tbb irnyban legyen elgaztathat, akkor tbbszrs elgazst
hasznlunk. A tbbszrs elgazs megfogalmazsnl azonban egy-kt
aprsgra oda kell figyelnnk.
if (felttel_1){
utasts_1;
}
else if (felttel_2) {
utasts_2;
}
else {
utasts_3;
}
Vissza
53
Programozs III.

Vissza
54
Egy konkrt pldban a vezrlszerkezet az albbiak szerint alakul:

short a=1;
if (a<0){
System.out.println(Negatv);
}
else if (a>0) {
System.out.println(Pozitv);
}
else {
System.out.println(Zrus);
}
A vgrehajts a kvetkez logika szerint mkdik: Elszr megvizsglja a

felttel_1 kifejezst. Ha ez igaz, akkor az utasts_1-et vgrehajtja,
majd a vezrls a kvetkez (az if szerkezet utni) utastsra kerl. Ha
felttel_1 hamis volt, akkor megvizsglja felttel_2 logikai rtkt.
Ha ez igaz, akkor az utasts_2, ha hamis, akkor utasts_3 kerl
vgrehajtsra, majd a vezrls a kvetkez utastsra lp.
A tbbszrs elgazs egy utastsnak szmt, mg akkor is, ha defincija tbb sorbl is ll, vagyis a fordt egy egysgknt kezeli! A felttelek
megfogalmazsakor gyelni kell arra, hogy azok egymst kizr esemnyeket szimbolizljanak. Amennyiben olyan gat definilunk, ahova a vezrls
sohasem juthat, a fordt hibt jelez. Ha a legutols else g hinyzik, s
egyik felttel sem teljesl, akkor az elgazs egyik utastsa sem lesz vgrehajtva, a program a kvetkez utastsra lp.
Egy ltalnos, tbbg esetsztvlaszts (szelekci) modellje az albbi
szerkezettel rhet el:
if (felttel_1) {
utasts_1;
}
utasts_2;
}
utasts_3;
}
else {
utasts_n;
}
A Java nyelv rklte a C nyelvbl ismert switch utastst, melyet egy klnleges elgazs tpusnak, esetsztvlasztsnak hvunk.
Vissza
54
Programozs III.

Vissza
55
switch (egsz-kifejezs) {
case konstans-kifejezs_1 :
utasts_1;
break;
/* tovbblps! */
utasts_2;
break;
default:
utasts_n;
}
Az utastshoz rve elszr az n. egsz-kifejezs rtkeldik ki. Itt olyan

kifejezseket adhatunk meg, amelyek kirtkelse utn megszmllhat
tpusba tartoz rtket (char, byte, short, int) kapunk (azaz lebegpontos kifejezseket, karakterlncokat mr nem adhatunk meg). A case
cmkk mellett ll konstans kifejezseknek az egsz kifejezssel kompatibilis tpusnak kell lennie. Futs kzben az egsz kifejezs kirtkelse
utn, ha valamelyik cmke rtke megegyezik a kifejezs rtkvel, akkor
az ott definilt utastsokat sorban vgrehajtja. Az utastsok ezutn sorban vgrehajtsra kerlnek, rcsorognak a kvetkez g utastsaira
fggetlenl a cmkktl hacsak egy break utasts a switch szerkezet
elhagyst ki nem knyszerti. Ha egyetlen konstans kifejezs sem felel
meg az egsz kifejezs rtknek, akkor a default cmke utni utastsok
kerlnek vgrehajtsra.
Ciklusok
Amennyiben bizonyos utastsokat, vagy utasts-sorozatokat egyms utn
tbbszr vgre kell hajtani, ciklusokat, itercikat hasznlunk. A Java
nyelv a ciklusszervezsi utastsait a C nyelvtl rklte.
Az utastsok ismtlse ltalban egy felttel (kilpsi felttel) teljeslse esetn megszakad. A program a soron kvetkez utasts vgrehajtst
kezdi meg. A felttel nlkli, rkk ismtld ciklust vgtelen ciklusnak
hvjuk. A ciklusokat a felttel kirtkelse szempontjbl kt csoportra
oszthatjuk: ell-, illetve htultesztel ciklus.
Az elltesztel ciklus a ciklusmag lefutsa eltt minden esetben kirtkeli a feltteles kifejezst. Mindaddig, amg ez a felttel igaz logikai rtket
szolgltat, a ciklusmag jra s jra megismtldik. Amikor a felttel mr
Vissza
55
Programozs III.

Vissza
56
nem teljesl, a program a ciklust kvet utastssal folytatja futst. Elfordulhat az az eset is, hogy a ciklusmag egyszer sem lesz vgrehajtva.
while (felttel) {
utastsok;
}
int i=0;
while (i<10){
System.out.println(i);
i++;
}
Abban az esetben, ha a ciklusmagot legalbb egyszer vgre kell hajtani,

akkor clszerbb a htultesztel ciklust hasznlni. Ekkor a felttel kirtkelse a ciklusmag els lefutsa utn rtkeldik ki elszr. Ha a felttel
igaz, akkor a ciklusmag utastsai megismtldnek. A ciklusbl val kilps
itt is a felttel hamiss vlsakor lehetsges.
do{
utastsok;
} while (felttel);
int i=0;
do {
i++;
} while (i<10);
Az elltesztel ciklusok egy specilis esetben amikor megszmolhat

lpsben kell utastsokat vgrehajtanunk a while helyett a for ciklusutastst hasznljuk. A for ciklusban a fulcsszt kvet zrjelben, pontosvesszkkel adjuk meg az inicializl- s logikai kifejezst, s a lptet
utastst. A szintaktika megengedi, hogy a kezdrtk adst, a felttel kifejezst, vagy a lptet kifejezst elhagyjuk. Az inicializtorban lehetsgnk
van loklis vltozk deklarlsra is. Ezek a vltozk csak a ciklus utastsblokkjn bell rtelmezettek, a blokk vgn megsznnek. Hasznlatval
vilgosan jelezhet, hogy ezt a vltozt csak a ciklusszervezs idejre definiltuk.
Vissza
56
Programozs III.

Vissza
57
for ( <inicializls> ; <feltteles kif.> ;<lptets> ) {

utastsok;
}
for (int i=0 ; i<10 ; i++){
}
A feltteles kifejezs alaprtelmezs szerint mindig igaz rtk, gy a teljesen hinyos for(;;); utasts szintaktikailag helyes ugyan, de szematikai
szempontbl nem, hiszen vgtelen ciklust eredmnyez.
Egy adott blokkbl nem csak a felttel hamiss vlsval van lehetsgnk kilpni. A break utasts amint a switch utastsnl is lthattuk
egy adott blokkbl val kilpsre szolgl. Ha a vezrls egy switch, for,
while, vagy do utasts blokkjban egy break utastst tall, akkor az t
tartalmaz blokk utni utastssal folytatja a vgrehajtst.
Amennyiben cmke : utasts; alak n. utastscmkt hasznlunk,
akkor a break cmke; alak hvs hatsra a program a cmkvel jellt
utastssal folytatja a vgrehajtst. Azonban metdusbl, vagy inicializtor
blokkbl val kiugrsra a break nem hasznlhat.
A continue utasts kizrlag egy while, do, vagy for utastson bell rtelmezett. Hatsra a ciklusmag htralv rsze tugorhat, a ciklus a
feltteles kifejezs kirtkelsvel folytatja futst.
int i=-10;
while (i < 10){
if (i==0) continue;
System.out.println(100/i);
i++;
}
Az utasts megadhat continue cmke; alakban is, ekkor a break-hoz

hasonlan egy cmkvel jellt utastssal folytatdik a program futsa. Metdusbl, vagy inicializtor blokkbl val kiugrsra a continue sem hasznlhat.
Megjegyzs: Amennyiben a struktrlt programozs alapelveivel val
kompatibilitsra treksznk az objektumorientlt programokban is, az
egyes algoritmusokat s vezrli szerkezeteket gy kell felpteni, hogy
azok ugr utastsokat ne hasznljanak! [Marton02]
Vissza
57
Programozs III.
Vissza
58
A ciklusok, itercik tetszleges mlysgben egymsba gyazhatk, azonban egy t szintnl mlyebb egymsba gyazsra csak ritkn van szksg.
Az ilyen ciklusok csak j szintaktikus tagolssal, illetve megfelel
kommentezssel lthatak t.
for (int i=2 ; i<100 ; i++){
System.out.print(i+ oszti: );
for (int j=1 ; j<=i ; j++){
if((i%j)==0) System.out.print(j+ );
}
System.out.println();
}
3.2.9. Tmbk
A hagyomnyos programozsi nyelvekben hasznlt a tmb, mint az azonos tpus elemekbl kpzett, fix elemszm sszetett adatszerkezet. A
tmbelemek indexelhetk. A Java nyelv is definil tmb adattpust, amelyet az alaptpusokbl vagy referencikbl kpezhetnk. A tmbk fbb
jellemzi:
Elre megadott, n szm elemet tartalmaz,
az adatok azonos tpusba tartoznak,
az elemeket a 0. elemtl n-1. elemig rhetjk el az indexels segtsgvel. Az indexelshez szgletes zrjelprt hasznlunk: [].
A tmbk egymsba gyazhatak, gy tbbdimenzis tmbket is deklarlhatunk. Azonban a Java a deklarlt tmbt mg nem engedi felhasznlni, az elemek szmra a memriban helyet is kell foglalnunk.
A tmb deklarcija
A tmb a Java rendszerben a referencia tpus vltozk kz tartozik. (A
C s C++ nyelvtl eltren ez egy valdi dinamikus memriaterletet
hasznl vltoz, s nem a mutat tpus egy msik alakja!) Egy tmb deklarcit az albbi kt mdon tudunk megadni:
<elemtpus>[] <tmbazonost>;
<elemtpus> <tmbazonost>[];
Mindkt jellsmd megengedett, csak kisebb klnbsgeket fedezhetnk

fel a deklarcis utastsokban:
int[] aT, bT;
int cT[], d;
Alkalmazott[] dolgozok;
// itt aT s bT is tmb
// cT egy tmb, de d elemi adat!
//referenciatmb deklarci
Vissza
58
Programozs III.
Vissza
59
A tmb deklarlsval megadtuk, hogy az adott referencia (aT, bT, cT s

dolgozok) egy egyelre meghatrozatlan mret tmbre fog hivatkozni.
Nagyon fontos szrevennnk, hogy a deklarci sorn nem adhatjuk meg
a tmb mrett, csakis a tmb ltrehozsakor (new opertorral, vagy az
inicializl blokkal)! Az int a[3]; alak deklarci fordtsi hibt
okoz!
A tmb ltrehozsa
A tmb deklarcija utn a futs alatt a memriban a megadott elemszmra helyet is kell foglalnunk a new opertor segtsgvel:
new <elemtpus> [mret];
ahol mret egy nemnegatv, maximum Integer.MAX_VALUE nagysg

egsz rtk.
A new opertor ltrehozza a memriban a megadott adatstruktrt s
visszadja a tmb referencijt, amelyet a tmb tpus vltoz rtkl kap.
Ezt a referencia rtket rtkl adhatjuk egy olyan referencia tpus vltoznak, amely egy ilyen tmbre kpes rmutatni.
Ez a tmb, ltrehozsa utn mr bejrhat, elemei hivatkozhatk, illetve adatokkal feltlthetk. A tmbelemek automatikus kezdrtket
kapnak, amely boolean tpus esetn false, char esetn \u0000, egszek
esetn 0, vals tpusoknl 0.0, s referenciatpusok esetn null rtk.
Az albbi pldkban egyszer tmb tpus vltozkat hozunk ltre:
int [] iT;
double[] dT;
String [] sT;
iT = new int[365];
dT = new double[365/12];
sT = new String[4];
// 30 az egszoszts miatt!
A tmblefoglalt mrett futsi idben is elrhetjk a kvetkez kifejezssel: tmbazonost.length. A tmb maximlis indexe length-1 lesz.
(Ez a szmadat valjban a tmbk Java nyelvbeli defincijban megadott konstansnak rtke.)
A tmb futsa sorn ismeri a mrett, amelyet futs sorn, minden
egyes tmbelem-hivatkozskor ellenrz is a virtulis gp. Ha ez az index
nem rvnyes, egy IndexOutOfBoundsException tpus kivtel keletke-
Vissza
59
Programozs III.
Vissza
60
zik, s a futs rendszerint megszakad (lsd: Kivtelkezels). Teht a C

nyelvvel ellenttben a tmbn kvli adatterletre nem hivatkozhatunk!
short [] aTomb;
// aTomb tmbreferencia deklarci
aTomb = new short[10]; // tmb ltrehozsa, helyfoglals
// tmb bejrsa s inicializlsa

for(int i=0; i < aTomb.length; i++){
aTomb[i] = i*5;
}
14. bra: A tmb elhelyezkedse a memriban

A tmbket tmrebb formban is ltrehozhatjuk. A deklarcis utastst
s a helyfoglalst egy lpsben is megtehetjk:
int[] honap = new int[12];
Lehetsgnk van a tmbket inicializl blokkal definilni. Ilyenkor a

deklarci sorn automatikusan az inicializl blokk kirtkelsvel
ltrejn a tmb objektum s megtrtnik a helyfoglals. Ezutn nem kell
s nem is szabad new opertort hasznlni! A tmbinicializl blokkot az
albbi formban adhatjuk meg:
<elemtpus> [] <tmbazonost> = { <rtk0>, <rtk1>, };
int[] aTomb = {1, 2, 3, 7, 11};
char[] maganh = { a, e, i, o, u};
boolean[] valaszok = { true, true, false};
double[] arak = {1202.1, 33.35};
String[] nevek = {Eszti, Reni, Eg, Peti, Sanyi};
Tbbdimenzis tmbk
A Java nyelv a C nyelvhez hasonlan a tbbdimenzis tmbket tmbkbl ll tmbkkel kpezi le. A tbbdimenzis tmbt gy deklarljuk,
hogy a tmb alaptpust is tmbknt deklarljuk. A tbbdimenzis tmb
ltrehozsa hasonl mdon mkdik, mint az egydimenzis esetben.
Vissza
60
Programozs III.
Vissza
61
<elemtpus>[][] <tmbazonost>;
double [][] a;
a = new double[2][3];
// 2 dim. tmb deklarci

// 2 dim. tmb ltrehozsa
Tbbdimenzis tmbt inicializl blokkal is ltrehozhatunk. A mvelet

hasonlt az egydimenzis esethez:
<elemtpus> [][] <tmbazonost> = {
{<rtk0>, <rtk1>, } , {<rtk0>, <rtk1>, },
};
int[][] honapNapjai = {
{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
};
15. bra: A ktdimenzis tmb memriamodellje

A tmbk trolsi mdszere egy kicsit sszetettebb, mint az egydimenzis
esetben. A tmb ltrehozsa sorn a tmbazonost referencija egy olyan
tmbt r el, amely tmbkre mutat referencikbl ll. A fenti definci
alapjn a honapNapjai referencia egy ktelem tmbre mutat. Itt a
honapNapjai[0] s a honapNapjai[1] egy-egy 13 elem egydimenzis
tmbre mutat referencia. (gy ezek a bels tmbk akr rtkl adhatak egy int[] tpus egydimenzis tmbnek is.)
Vissza
61
Programozs III.

Vissza
62
A trolt tmbelemeket egyszeren elrhetjk a honapNapjai[x][y]

alak hivatkozssal. Itt valjban a referencikon keresztl vgl elrnk
az int tpus trolt adatokhoz. (A mdszer ismers lehet a C nyelv mutat aritmetikja alapjn.)
A tbbdimenzis tmbket tbb lpsben is ltrehozhatjuk. Elszr
egy olyan tmbt hozunk ltre, amely majd tartalmazza a tbbi tmbre
mutat referencit. Ezutn az egyes referencikhoz lefoglalunk egy-egy
tmbt. Ezek az jabb tmbk akr klnbz mretek is lehetnek, gy a
modellezend problmhoz legjobban illeszked struktrt is elkszthetnk!
int[][] alsoMatrix = new int[3][];
for (int i=0; i < alsoMatrix.length; i++ ){
alsoMatrix[i] = new int[i+1];
for (int j=0; j < alsoMatrix[i].length; j++ ){
alsoMatrix[i][j] = 1;
}
Ebben a pldban egy als hromszgmtrix elemeit trol ktdimenzis

tmbt ksztettnk el. Az els sorban deklarltunk s lefoglaltunk egy
hromelem tmbket tartalmaz tmbt. Ezutn egy ciklus segtsgvel
a hrom tmbelemhez hozzrendeltnk egy-egy egydimenzis tmbt,
amelyek elemszma 1, 2 illetve 3 volt. Legvgl egy bels ciklussal ezeket a
tmbelemeket inicializltuk 1 kezdrtkkel.
rtkads tmbk kztt
Tmbk kztt akkor beszlhetnk rtkadsrl, ha tpusaik kompatibilisek. Adott t1 tmb rtkads szerint kompatibilis t2 tmbbel a kvetkez esetekben:
Elemi adattpus esetn, ha t1 s t2 elemtpusa azonos;
Referencia tpusok esetn, ha t2 elemtpusa azonos t1 elemtpusval
(osztlyval), vagy annak egy leszrmazottjval.
A tmbk rtkadsakor a tmbreferencihoz j rtket rendelnk. rtkadskor a tmbelemek nem msoldnak, gy az rtkads rvnyesnek
szmt akkor is, ha a kt tmb nem azonos elemszm.
int [] t1 = new int[12];
int [] t2 = new int[100];
t1 = t2;
Vissza
62
Programozs III.
Vissza
63
A t1=t2 utasts hatsra a t1 tmbreferencihoz hozzrendeltk a t2

referencijt. Ezutn teht mindkt azonostval ugyanazt a 100 elem
tmbt rjk el. Az eredetileg t1-hez rendelt 12 elem tmb mr nem
lesz soha tbb elrhet (hacsak nem jegyeztk fel a referencijt valahol).
A tmbk megszntetsrt a virtulis gp szemtgyjt mechanizmusa
felel (lsd: 80. oldal).
3.2.10. Karakterek s szveges adatok
A Java nyelv char tpusa egyetlen, ktbjtos unicode karakter brzolsra

alkalmas alaptpus. A unicode szabvny 65536-fle klnbz rsjelet
klnbztet meg, ezrt hasznlhatjuk az azonostkban, illetve a vltozkban az kezetes, rmai s egyb karaktereket. Egy karaktert aposztrfok kztt helyeznk el: a. A char egsz jelleg megszmllhat tpus,
gy knnyen konvertlhat egsz rtkk s vissza.
Az albbi tblzatban lthatjuk azokat a karakter konstansokat, melyeknek a Java nyelvben klnleges jelentse van:
karakterkd
\n
\r
\t
\f
\\
\
\
\b
\000
\u0000
jelents
soremels
kocsivissza
vzszintes tab karakter
lapdobs
a \ karakter
idzjel
aposztrf
backspace
karakter oktlisan (0-377)
unicode karakter hexadecimlisan
(\u0000 \uffff)
4. tblzat: A karakteres escape szekvencik

A karakteres rtkekhez hasonlan n. szvegliterlokat is megadhatunk
idzjelek kztt: Java programozs. Ezek tulajdonkppen konstans
karakterlncok, s korltozott a hasznlhatsguk.
A szvegek, illetve karakterlncok kezelsre a Java nyelv nem ad meg
alaptpust, erre a Java krnyezetben definilt String osztlyt hasznljuk.
Vissza
63
Programozs III.
Vissza
64
A String osztly
A String osztly konstans karakterlncok trolsra alkalmas. Az osztly
a karakterlncokat karakteres tmbben trolja kt szmrtkkel (a sztring
els karakternek pozcijt, s a szveg hosszt), s definilja a hozz
tartoz alapmveleteket (hossz, kis-nagybets konverzi, sszefzs, szszehasonlts, rszsztring kpzs, karakterek keresse stb.). A ltrehozs
utn azonban a String tpus objektumot mdostani mr nem tudjuk.
Az ilyen tpus vltozt leggyakrabban az albbi utastsokkal hozunk
ltre (pldk):
String szov1 = new String(els szveg);
String szov2 = msodik szveg;
String szov3 = Eredmny =+3 ;
A hrom megadsi md egyenrtk, a msodik s harmadik esetben nem

rtuk ki a new kulcsszt, itt automatikusan trtnik meg a pldnyosts (a
fordt automatikusan kiegszti a new-val).
A harmadik esetben a 3-as egsz rtket a fordt az automatikus konverzi segtsgvel szvegg alaktja, majd ezt a szveget hozzfzi az
eltte ll karakterlnchoz. Vgl a kapott j karakterlncra mutat referencit kapja meg a szov3 referencia.
Megjegyzs: A szmrtkek konverzijakor a virtulis gp a szmrtk
csomagol osztlynak toString() metdushvsval alaktja szvegg
az adott rtket.
A sztringek automatikus konverzija s a + opertorral trtn sszefzse erforrs-ignyes mvelet, helyette a StringBuffer osztly hasznlata ajnlott!
Sztringet karaktertmbkbl, bjttmbkbl, vagy annak egy rszbl is
kpezhetnk.
char [] karaktertomb = {P, i, s, t, i, k, e};
byte [] bajttomb = {65, 66, 67, 68, 69, 70};
String s1 = new String(karaktertomb);
// Pistike
String s2 = new String(bajttomb);
// ABCDEF
String s3 = new String(karaktertomb, 1, 4);
// isti
String s4 = new String(bajttomb, 3, 2);
// EF
Vissza
64
Programozs III.
Vissza
65
A sztringek kezelse sorn a pozcionls 0-tl a szveghossz-1 rtkig

terjedhet. A szveget nem indexelhetjk tl (a tmbkhz hasonlan)
klnben a StringIndexOutOfBoundsException kivtel keletkezik.
Sztringekkel az albbi mveleteket hajthatjuk vgre:
Sztring ellltsa karakterlnc-literlbl, karakter-, vagy bjttmbbl.
Megkaphatjuk a szveg hosszt (length), megkereshetjk egy sztring
adott index karaktert (charAt), rsz-szvegt (subString), s a
szveg elejrl, vgrl levghatjuk a fehr karaktereket (trim).
Egy sztringet sszehasonlthatunk egy msik sztringgel referencia
(equals) s karakter szinten (compareTo), illetve megllapthat, hogy
egy sztring tartalmaz-e egy msikat (startsWith, endsWith,
regionMatches).
A sztringhez hozzfzhetnk egy msik sztringet (concat, vagy +), a
szveg karaktereit kis- s nagybetss alakthatjuk (toLowerCase,
toUpperCase),
A szveg egyes karaktereit kicserlhetjk (replace)
A szvegben karaktereket s rsz-sztringeket kereshetnk (indexOf)
A sztringekbl ll tmbk ltrehozsra is lehetsgnk nylik. Legegyszerbb esetben a tmbt sztring literlokkal inicializlhatjuk. Ekkor a
sztringtmb vltoz egy olyan tmb tpus referencia, amely String objektumokra mutat referencikat tartalmaz.
String [] honapok = {janur, februr, mrcius};
Az gy definilt tmb elemeit azutn elrhetjk a honapok[index] alak

hivatkozsokkal, illetve a tmbelemre, mint String objektumra meghvhatjuk a sztringkezel fggvnyeket is:
System.out.println(honapok[1].charAt(0));
//kimenet: f
A fenti defincit termszuetesen megadhatjuk a new opertor segtsgvel

is gy, hogy az egyes tmbelemekhez futs kzben rendelnk rtket.
String[] honapok = new String[12];
honapok[0] = janur;
honapok[1] = februr;
honapok[2] = mrcius;
Vissza
65
Programozs III.
Vissza
66
Megjegyzs: Az indexelssel vigyznunk kell, mert ha olyan tmbelemre

prblunk hivatkozni, amelyikhez mg nem rendeltnk egyetlen sztring
rtket se (pl: honapok[3].charAt(0)), hiszen akkor a futs kzben egy
NullPointerException kivtel keletkezik!
16. bra: Tmbk kpzse karakterlncokbl

Ilyen karakterekbl ll tmb a main osztlymetdusban paramterknt
szerepl String args[] is. Segtsgvel a program indtsakor megadott
parancssori paramtereket rhetjk el szveges adatknt. (Figyelem, az
args[0] mr az els valdi paramter rtkt veszi fel!)
/** ArgumentumKiiro.java
* hvsa: java ArgumentumKiiro param1 param2 param3 ....
*/
public class ArgumentumKiiro {
public static void main(String[] args) {
if (args.length > 0) { // paramterlista-tmb elemszma
for (int i = 0; i < args.length; i++)
System.out.println(args[i]);
} else {
System.err.println("Nincsenek paramterek!");
}
}
}
A tmbkezels tovbbi lehetsgeirl a 8.5. fejezetben ejtnk mg nhny

szt.
Vissza
66
Programozs III.

Vissza
67
A StringBuffer osztly
Mint lttuk, a String osztly konstans karakterlncokat kezel. A virtulis
gp minden karakterlnc-sszefzskor egy-egy jabb memriaterletet
foglal az jonnan elll szveges adat szmra. Az ilyen mveletek nagyon memriapazarlak (a virtulis gp a lefoglalt s nem hasznlt memriaterleteket csak a szemtgyjtssel tudja ismt hasznlhatv tenni)
ezrt hasznlatuk kerlend!
Abban az esetben, ha a futs alatt tbb szrtingbl ll szveges adatot
szeretnnk ellltani, amelynek rszeit, hosszt stb. ms-ms idpontban
kapjuk meg, akkor az ilyen szvegmveletekhez a StringBuffer osztlyt
kell hasznlnunk. A StringBuffer osztly a String osztlyhoz hasonlan
a Java krnyezet rsze. A String osztlyban ismertetett alapmveleteken
kvl a kvetkez mveletek elvgzsre hasznljuk:
Egy String objektumot StringBuffer-r alakthatunk, s vissza.
A szveges adathoz hozzfzhetnk, vagy az adatba egy msik szveget beszrhatunk (append, insert).
A szveg hossza mdosthat (rvidts, bvts). A StringBuffer
objektum rendelkezik egy capacity adattaggal, amely az objektum
tnyleges memriafoglalst mutatja. A szveg aktulis hosszt a
length() metdussal kaphatjuk meg. Amennyiben a hozzfzs, vagy
beszrs sorn a szveg nem frne be az adott memriaterletre, a
StringBuffer mrett a virtulis gp megnveli.
A szveg megfordthat (reverse).
A szvegbl karakterek, vagy rsz-szvegek trlhetk.
A Java osztlyknyvtrakban gyakran tallkozunk StringBuffer tpus
referencival visszatr metdusokkal.
Az albbi pldaprogram-rszletben a StringBuffer osztly mkdst tanulmnyozhatjuk (a teljessg ignye nlkl):
//Konstrukci
StringBuffer szoveg1 = new StringBuffer(2);
//Konstrukci egy mr definilt sztring segtsgvel
StringBuffer szoveg2 = new StringBuffer("Almafa");
//Automatikus trbvts:
szoveg1.append("Nagyon hossz szveg! ");
//A length() a tartalmazott szveg hosszt, a capacity() a
//StringBuffer objektumban rendelkezsre ll helyet jelenti
int hossz = szoveg1.length();
int kapacitas = szoveg1.capacity();
Vissza
67
Programozs III.

Vissza
68
System.out.println(szoveg1);
System.out.println("szoveg1 hossza = " + hossz);
System.out.println("szoveg1 kapacitsa = " + kapacitas);
System.out.println("---------------------------------\n");
//A StringBuffer objektum kibvtse
szoveg1.ensureCapacity(20);
szoveg2.ensureCapacity(50);
System.out.println(szoveg2);
//Elemi rtkek hozzfzse s beszrsa a StringBuffer
//objektumba
double d = 3.54;
int i = 100;
char [] karaktertomb = {'P', 'i', 's', 't', 'i', 'k', 'e'};
szoveg2.append(d).append(i);
szoveg2.insert(0, karaktertomb);
// A StringBuffer objektum mdosthat:
char regi = szoveg2.charAt(7);
szoveg2.setCharAt(7, 'a');
// A StringBuffer objektum tartalmnak rvidtse:
szoveg2.setLength(2);
// A StringBuffer objektum kapacitsnak cskkentse:
szoveg2.trimToSize();
System.out.println("szoveg2 = " + szoveg2);
System.out.println("szoveg2 hossza = " + szoveg2.length());
System.out.println("szoveg2 kapacitsa = " +
szoveg2.capacity());
3.2.11. A csomagol osztlyok
Minden elemi tpushoz lteznek n. csomagol vagy burkol osztlyok

(wrapper). Ezek olyan osztlydefincik (Boolean, Character, Integer,
Long, Float, Double), amelyek egy adott rtket egy objektumban helyeznek el, rjuk referencikkal hivatkozhatunk, s az osztlyban definilt
mveleteket vgrehajthatjuk. sszetett adatszerkezetekben hatkonyan
hasznlhatak, ahol az egyes elemeket referencival kell elrnnk. gy az
olyan kontner objektumok, amelyek csak objektumokat trolhatnak, alkalmasak elemi adatok kzvetett trolsra is. Megjegyezzk, hogy az ilyen
jelleg adattrols nagyon memriapazarl.
Float f = new Float(3.14);
Az f referencira ezutn rtelmezhet szmos mvelet, amely a trolt

rtket megvizsglja, konvertlja. Ugyangy hasznlhat a tbbi csomagol
osztly is, az adott tpusra jellemz mveletekkel. A csomagol osztlyok
hasznlata elnys lehet a mr emltett kontner osztlyokban, vagy min-
Vissza
68
Programozs III.
Vissza
69
den olyan helyen, ahol az adott rtket objektumknt szeretnnk felhasznlni, esetleg konvertlni.
3.2.12. A felsorolt tpus (enum)
A Java 5.0-s kiadsban bevezettk a felsorolt tpusokat [12]. Ezek a felsorolt tpusok (enumercik) olyan jelleg adatszerkezetek, amelyeket mr
az ANSI C nyelv is hasznlt ugyanilyen nvvel. A mkdsi alapelve hasonl, mgis a megvalstsban szmos klnbsget tallunk. Elszr
azonban tekintsk t, hogy mikor hasznlhatunk felsorolsokat!
Hagyomnyos megoldsok
A rgebbi Java verzikban felsorolt szerkezeteket hasznltunk pldul egy
munkafolyamat llapotainak kvetsre. Ekkor az egyes sttuszokat egyegy konstans rtkkel lehetett definilni:
public class Kapcsolat{
public static final int
RENDBEN = 0;
HIBA= 1;
KAPCSOLODAS = 2;
ADATFELOLTES = 3;
A konstansok megadhatk a hasznlni kvnt osztlyban osztlyvltozknt (lsd: 4.5. fejezet), vagy egy fggetlen interfszben is (lsd: 5. fejezet). Ennek a megadsnak az elnye az, hogy a konstansok csak 4-4 bjtot foglalnak (int tpus) s rtkk mg szelekciban (switch) is felhasznlhatak.
Azonban ennek a megoldsnak szmos htrnya is van: a fordts sorn a konstans rtkek mr behelyettestve jelennek meg a kdban, nincs
lehetsg tpusellenrzsre, nyomkvetskor, vagy az rtket kiratva nem
szolgltat informatv eredmnyt, s fejlett adatszerkezetekbe sem helyezhet el egyszeren (hiszen ott csak referencikkal dolgozunk).
Megadhat a konstans szveges rtkknt is. Ekkor ugyan javul az olvashatsg, de megn az adatterlet, s a vezrls bonyodalmasabb vlik
a sztringmveletektl.
Msodik lehetsgknt lehetsgnk van egy olyan osztly definilsra is, amely az elzeken tlmutatva csak osztlyszint szveges konstansokat tartalmaz, s szmos mveletet megvalst, de nem rendelkezik
publikus konstanssal.
Vissza
69
Programozs III.

Vissza
70
public class Kapcsolat{

private String nev;
private Kapcsolat(String nev){ this.nev = nev;}
public String toString(){return nev;}
//statikus pldny konstrukci az osztly betltsekor
public static final Kapcsolat RENDBEN
= new Kapcsolat("rendben");
public static final Kapcsolat HIBA
= new Kapcsolat("hiba");
public static final Kapcsolat KAPCSOLODAS
= new Kapcsolat("kapcsolds");
public static final Kapcsolat ADATFELOLTES
= new Kapcsolat("adatfeltlts");
}
Megjegyzs: A konstruktor azrt kap privt minstst, hogy csak az osztlybetlts sorn jjjenek ltre a konstans objektumok (static final minsts), s a ksbbiekben ne lehessen tbb ilyen objektumot ltrehozni!
Az gy megadott konstansok egyszeren felhasznlhatk ms osztlyokbl:
System.out.println(Kapcsolat.HIBA);
Az egyetlen htrnya ennek a megoldsnak az, hogy tbb erforrst kt le,

s egy kicsit pazarl a trgazdlkodsa. Ezek a tpusok nagyon sok esetben
hasznlhatk, de mivel referencia tpusrl van sz, egy switch-ben nem
hasznlhatjuk fel, hiszen ott csak egsz-kifejezsek llhatnak.
Enum tpus definilsa
A Java fejleszti a fenti megoldsok tvzseknt a felsorols jelleg
adatszerkezetekhez megalkottk az enum tpust, vagy ms szhasznlatban az enum osztlyt, hiszen a tpust valjban a java.lang.Enum osztlyban definiltk. Ez az osztly nagyban eltr az eddig megismertektl,
mint azt ltni fogjuk az albbiakban. A tpusban felsorolt rtkeket enum
konstansnak hvjuk, hiszen azok a futs sorn nem vltoztathatjk meg
rtkket.
Ugyangy az enum tpus vltoz definilsa egyszerstett, eltr a hagyomnyos pldnyoststl, s elmarad a new kulcssz is. A definci
szintaktikjban leginkbb az ANSI C-vel val analgia fedezhet fel.
Enum tpust az albbi mdon definilunk:
Vissza
70
Programozs III.

Vissza
71
enum <enumtpusnv> {<enumkonstans>, [<enumkonstans>, []]}

public class FelsorolasMinta{
public enum Kapcsolat {RENDBEN, HIBA, KAPCSOLODAS,
ADATFELTOLTES};
public enum Napok {HE, KE, SZE, CSU, PE, SZO, VAS};
Ahol az enum tpusnv a Kapcsolat, a {}-ben lev felsorols pedig az

enumkonstansokat jelli. Az enumkonstansokat jellegk miatt csupa
nagybetvel rjuk, a Java nvadsi konvencii szerint.
Jellemzi:
Az enum tpusok nll osztlyok, melyek a java.lang.Enum osztlybl szrmaznak, teht az osztlyokra s interfszekre vonatkoz
szablyok alapjn mkdnek.
Enum tpust csak osztly, vagy pldnyvltozknt definilhatunk,
blokkon belli loklis vltozknt nem!
Az enum tpusok nem rendelkeznek publikus konstruktorral, ezrt
csak a deklarcikor kaphatnak kezdrtket.
Az enum tpusok egyes konkrt rtkei static final mdostval
rendelkeznek, teht futsi idben nem vltoztathatjk meg rtkeiket.
Az enum konstansok konkrt rtkekkel val sszehasonltsakor a ==
mvelet hasznlhat, s nem szksges az equals() metdust hvni.
Az enum tpusok implementljk a Comparable s a Serializable
interfszt, amely nagyban megknnyti a tpus felhasznlhatsgt kollekcikban (lsd: 9.1. fejezet).
Az enum tpusokban hasznlt toString() metdus az enum konstans
cmkjnek karaktereit szolgltatja
(Kapcsolat.RENDBEN.toString() => RENDBEN)
Az enum tpusokban hasznlt valueOf() metdus a toString() ellentte, a szveges reprezentcibl konstans rtket szolgltat
(Kapcsolat.valueOf(HIBA) => Kapcsolat.HIBA)
Az enum tpus rtkeit tmbbe konvertlhatjuk a values() metdussal.
A java.lang.Enum osztlyt csak a fenti mdon lehet pldnyostani,
a new opertor itt nem alkalmazhat, illetve leszrmaztatni sem lehet
(final osztlyminsts).
Az enum konstans rtkek nem egyszeren egsz konstansok, hanem
a felsorols osztly egyes statikus pldnyai. A fordt rzkeny is
ezekre a tpusokra, kt eltr enum tpus nem hasonlthat ssze.
Vissza
71
Programozs III.

Vissza
72
Az enum tpus felhasznlsa

Az enum tpusknt definilt konstansokra a kvetkez alakban hivatkozunk:
Enumtpusnv.ENUMKONSTANSNV.
Az enum tpusbl hozhatunk ltre vltozkat, amelyek rtkknt az enum

tpus egy-egy konstans rtkt vehetik fel. Az enumkonstans szerepelhet
rtkads jobb oldaln, mveletekben s metdusok paramtereiben, vagy
visszatrsi rtkknt.
//enum tpus loklis vltoz definilsa
Kapcsolat statusz = Kapcsolat.HIBA;
// Ez a vltoz csak enumtpus konstans rtkeit veheti fel
statusz = Kapcsolat.JO; //OK.
statusz = "HIBA";
// fordtsi hiba, nem kompatibilis
tpusok!
statusz = Napok.SZE; //fordtsi hiba, nem kompatibilis
tpusok!
// enum vltoz mveletben:
if (statusz == Kapcsolat.JO)
System.out.println ("A kapcsolat minsge j!");
Az enum tpus vltozk felhasznlhatak switch szelekciban is. Az

elgazs szerkezete nagyon egyszer, hiszen a switch-ben elg a megadott enumtpus konstans rtkeit kell megadni s megvizsglni.
(szrevehetjk, hogy a kdolsi szintaktika kiegyszersdik, hiszen a case
gakban nem kell megadni a tpust, mert az a vizsglt vltoz tpusbl
egyrtelmen kvetkezik.)
// az enum tpus vltoz felhasznlsa szelekciban
switch (statusz){
case JO:
System.out.println ("A kapcsolat felplt.");
break;
case HIBA:
System.out.println ("A kapcsolat nem plt fel!");
break;
case SZAKADT:
System.out.println ("A kapcsolat megszakadt!");
break;
}
Vissza
72
Programozs III.

Vissza
73
Megjegyzs: A Java 6. verzitl kezdden a fordt szigorbban kezeli a

felsorolsokat. Amennyiben az enum tpus switch szerkezetben szerepel,
s nem fejtnk ki minden lehetsges case gat, illetve elhagyjuk a default
cmkt, a fordt figyelmeztet zenetet kld. [13]
Az enum tpusok kiegsztse, kiterjesztse
Ahogy a fentiekbl lttuk, a felsorolt tpusok tulajdonkppen egyszerstett osztlydefincik, melyeket egyszerstett szintaktikval hozhatunk
ltre s rugalmasan kezelhetnk. Ezeken tl szmos egyb lehetsgnk
van a felsorolt tpusok kiegsztsre: pl. az egyes enumkonstans azonostkhoz hozzrendelhetnk tnyleges konstans rtkeket, illetve az enum
tpusba metdusokat is pthetnk.
Abban az esetben, ha ilyen kiterjesztett felsorolt tpust szeretnnk hasznlni, akkor azt, mint egy enum tpus osztlyt kell definilni az albbi
mdon:
public class EnumTeszt{
public enum Honapok {JAN (31), FEB (28), MAR (31);
private int nap;
private Honapok(int nap){this.nap=nap;}
public int napszam(){return nap;}
};
Megjegyzs: A konstans cmkk mgtt a konstruktornak sznt paramter

ll zrjelben, s a konstansok felsorolsa utn pontosvessz ll. Ezutn
kvetkezik a privt konstruktor, s a metdusok. A konstruktornak azrt
kell privt minstst adni, mert az enum tpus csak a {}-jelek kztti
rszben inicializlhat, futs kzben j rtkkel kibvteni enm lehet.
A kiterjesztett enum tpust pldul az albbi mdon hasznlhatjuk fel:
public muvelet(){
Honapok elsoHonap=Honapok.JAN;
// kiterjesztett enum
System.out.println(elsoHonap);
// kimenet: JAN
System.out.println(elsoHonap.napszam());
//kimenet: 31
}
}
Vissza
73
Programozs III.
Vissza
74
A kiterjesztett enum tpus vltozl kirsakor az automatikus konverzi

ugyangy mkdik, mint ms objektumok esetn. (Bvebben lsd: 3.2.6.
fejezet.)
Az enum tpusok egyes elemeihez nll viselkedst is rendelhetnk.
Ekkor a felsorols egyes elemeihez sajt, felltlttt metdusokat is rendelhetnk. (A megvalstst a Java nvtelen bels osztlyokkal vgzi. Lsd:
5.4.3. fejezet.)
public enum Honapok {
JAN (31) {
public String muvelet(){ return "esemny janurban";}
},
FEB(28) {
public String muvelet(){ return "esemny februrban";}
},
MAR(31){
public String muvelet(){ return "esemny mrciusban";}
};
public int nap;
private Honapok(int nap){this.nap=nap;}
public int napszam(){return nap;}
public abstract String muvelet();
};
A kiterjesztett enum tpus vltozt, s a hozz kapcsold metdust a

kvetkezkppen hasznlhatjuk fel:
Honapok aktualisHonap=Honapok.FEB;
System.out.println(aktualisHonap.muvelet());
3.3. Krdsek
Melyek a Java nyelv alaptpusai?

Mit jelent a referencia tpus?
Hogyan definilhatunk egy osztlyt?
Mirl ismerjk fel egy osztly konstruktort?
Sorolja fel a Java nyelv ngy hozzfrsi kategrijt!
Mit jelent az automatikus tpuskonverzi?
Mit jelent az explicit konverzi?
Mit jelent az automatikus szvegkonverzi?
Milyen vezrlsi szerkezeteket ismer a Java?
Mi a klnbsg az elgazs (if) s a szelekci(switch) kztt?
Milyen ciklusfajtkat definil a Java?
Vissza
74
Programozs III.

Vissza
75
Hogyan adhatunk meg egy egydimenzis tmb adatszerkezetet?

Mirt kell helyet foglalni egy tmbnek?
Mirt nem helyes az int a[4]; utasts?
Hogyan rtelmezzk a tbbdimenzis tmbket?
Mi a klnbsg a String s a StringBuffer osztly kztt?
Mik azok a csomagol osztlyok?
Mire hasznlhatjuk a felsorolt tpusokat?
3.4. Feladatok
1. Ksztsen olyan pldaprogramot, melyben egy, illetve ktdimenzis
tmbben trol egsz, ill. vals rtkeket. A trolt rtkeket jrja be s
jelentse meg!
2. lltsa el egy n x m-es mtrix transzponltjt!
3. Gyakorolja a karakterlncok kezelst az albbi pldk alapjn:
Felhasznli adatokat egy sorban adunk meg, vesszkkel elvlasztva: (nv, lakcm, irnytszm, telefon). A karakterlncbl nyerje ki
az egyes rszadatokat.
Egy mondat, vagy hosszabb szvegrsz szavainak (fehr karakterek hatrolta egysgek) sorrendjt fordtsa meg!
Egy tetszleges osztly toString() metdust rja meg
StringBuffer segtsgvel. (Azaz a metdus ne tartalmazzon
String objektumokat, s karakterlnc sszefzst "+" sem!)
4. Csomagol osztlyok felhasznlsval konvertljon karakterlncban
megadott rtkeket egsz, illetve vals szmokk!
5. Tervezzen egyszer, illetve kiterjesztett felsorolt tpusokat a kvetkez
fogalmakhoz:
ht napjai,
kzlekedsi eszkzk,
sportgak.
Vissza
75
Programozs III.
Az osztlyok hasznlata
Vissza
76
4. Az osztlyok hasznlata
A 3.2.2. fejezetben mr megismerkedtnk az osztlyok nhny alaptulajdonsgval, most pedig egy tfogbb kpet rajzolunk, hogy hogyan is pl
fel egy Java program, s hogy milyen eszkztrat ad keznkbe a Java API
(a Java osztlyknyvtrak gyjtemnye).
4.1. Az osztlyok, s az objektumok letciklusa
A Java programok legkisebb nll egysgei az osztlyok. Egy-egy osztly
a valsg egy jl krlhatrolhat egysgt rja le. Ezek, ahogy azt az objektumorientlt modellezs elmleti rszben kifejtettk, a konkrt objektumok lersnak absztrakt modelljei. Pldul lehetnek az osztlyok egy
vllalatnl dolgoz szemlyek nyilvntartsra szolgl modellek, vagy
ppen egy ktirny dinamikus listt ler adathalmaz s szablyrendszer.
Mkdse sorn a program pldnyostja az osztlyokat, vagyis a modellek
smja szerint konkrt objektumokat (pldnyokat) hoz ltre. Minden
objektum rendelkezik egy bels llapottal, amely egyrszt befolysolja a
mveletek vgrehajtst az objektumon, msrszt a mveletek hatsra
meg is vltozhat.
A pldnyostssal ltrejv objektum bels llapota a kezdllapot. A
mveletek vgrehajtst az egyes objektumok kezdemnyezhetik nmagukra, vagy ms objektumokra.
Megjegyzs: Az objektum, pldny vagy egyed kifejezs az objektumorientlt terminolgiban ugyanazt a fogalmat takarja, az egyes szakirodalmak
ezeket felvltva hasznlhatjk.
Az osztlyokat (class) a Java nyelvben egy logikailag kt rszre bonthat
definci rja le. Az els rsz deklarlja azokat a vltozkat, (adattagok,
tulajdonsgok), amelyekkel egy objektum llapota lerhat, jellemezhet,
s amelyeknek konkrt rtkeiben az azonos tpus objektumok klnbzhetnek egymstl. Az osztly minden pldnya sajt memriaterlettel
rendelkezik ezekbl a vltozkbl. Szoksos mg pldnyvltozknak is
hvni ket.
A msodik rsz az objektumok viselkedst, mkdst s az objektumnak kldhet zenetek feldolgozst vgz mveleteket (metdusok,
Vissza
76
Programozs III.
Vissza
77
tagfggvnyek) tartalmazza. Egy metdus hasonlt a hagyomnyos programozsi nyelvek eljrsaira s fggvnyeire. Ms szval egy metdus egy
olyan utastssorozat, amely paramtereket fogadhat, az objektum adattagjain mveleteket hajthat vgre, s rtket adhat vissza.
A metdushvs nem ms, mint az adott objektum fel irnyul zenetklds. A metdus defincija osztly szint, hiszen minden egyes objektumon ugyanazt az utastssorozatot hajtja vgre, de a metdus futsakor mindig egy konkrt objektum adattagjaival dolgozik.
Az objektumorientlt mdszertan a tpusokat mveleteikkel egytt tekinti rtelmes egysgnek (egysgbe zrtsg). Ebbl a szempontbl egy
osztly nem ms, mint egy teljes tpusdefinci, amely lehetv teszi az
adatok s az adatokat kezel mveletek egyttes kezelst. A 3.2.7. fejezetben trgyalt hozzfrsi kategrik alkalmazsval megvalsthat az
adatok klvilg ell trtn elrejtse is.
Az albbiakban egy egyszer osztlyt definilunk. A LinearisFuggveny
osztly az elemi matematikbl megismert egyszer fggvnyt r le.
// A lineris fggvny osztly defincija
public class LinearisFuggveny {
//sajt adattagok, tulajdonsgok
private double a,b;
//konstruktor, amellyel majd pldnyostunk
public LinearisFggveny(double a_, double b_) {
a=a_; b=b_;
}
// metdusok
// a lineris fggvny -> y rtke x helyen, azaz ax+b
public double y(double x) {
return a*x+b;
}
// egy jabb metdus, amelyik szvegesen is megjelenti
// a fggvny jellemzit
public String toString() {
return "Lineris fggvny y="+a+"*x+"+b;
}
}
Ez a plda egy nll osztlydefinci, s teljes fordtsi egysget kpez.

Ezt az osztlyt csak a LinearisFuggveny.java forrsfjlban lehet elhe-
Vissza
77
Programozs III.
Vissza
78
lyezni, a Java nvadsi konvencii miatt. Ezutn az osztly mr lefordthat, s sikeres fordts utn egy LinearisFuggveny.class trgykd llomnyt kapunk.
Az osztly defincijt a class kulcssz vezeti be, amelyet az osztly
neve kvet. Az osztlyokat nagybetvel kezdd azonostval ltjuk el.
sszetett osztlynv esetn nem hasznlhatunk szkzket, a szavakat
egyberjuk, s minden szt nagybetvel kezdnk, esetlegesen a _ karakter is hasznlhat. A nvadsnl clszer fneveket vlasztani.
Az osztly hozzfrsi kategriba is sorolhat, aszerint, hogy honnan
engedlyezzk majd ennek az osztlynak a pldnyostst. Ezt a class
kulcssz el rt mdost szval tehetjk meg. Ez a mdost a vele elltott egysg egszt ruhzza fel a hozzfrsi kategria tulajdonsgaival.
Egy osztly definilsakor a public, final, vagy abstract mdostt
hasznlhatjuk.
A public mdost azt jelenti, hogy az osztlyt a nyilvnos hozzfrsi kategriba soroljuk, teht ez brmely ms osztlyokbl hivatkozhat,
s pldnyosthat. Ha az osztly el nem rjuk ki a public mdostt,
akkor azt az osztlyt csak a sajt csomagjn belli (azonos knyvtrban
lv) osztlyokbl rhet el. Az abstract s final mdostkrl az
rklds fejezetben lesz sz. Az osztly neve utn tallhat kapcsos zrjelek kztt az osztly tnyleges defincija ll.
Az osztly defincija sorn elszr az adattagokat, majd a metdusokat adjuk meg. Pldnkban kt privt vltozt a, b s hrom metdust
(LinearisFuggveny, y, toString) definiltunk.
A vltozkat kisbetvel kezdd fnvvel, a metdusokat kisbetvel
kezdd igvel szoks azonostani. (Az sszetett, tbb modulbl s komponensbl ll munkkban az eligazodst nagymrtkben knnyti a Java
kdolsi konvencik betartsa. Lsd: 12. fejezet) Egy adott rtk belltst ltalban a set, egy rtk lekrdezst a get szcskval kezdnk
(setName, getName). Egy adott tulajdonsg fennllst vizsgl, logikai
rtket visszaad metdust a megfelel mellknvrl clszer elnevezni,
s azt is eltaggal szoks elltni (isEmpty).
Megjegyzs: Sajnos a magyar s az angol nyelv eltr jellegzetessgei miatt
ez az elv nem mindig tarthat be. A programokban nagyon sokszor keverednek a magyar s angol metdusnevek. Egy programon bell clszer
azonban minl inkbb egysges elnevezseket hasznlni.
Vissza
78
Programozs III.
Vissza
79
Az adattagok megadsa utn fejtjk ki a LinearisFggveny nev

konstruktort. A konstruktor, mint azt a 3.2.2. fejezetben kifejtettk egy
specilis metdus, az osztly pldnyostsakor kerl vgrehajtsra.
Pldnkban kt olyan metdust definiltunk, amely rtket ad vissza.
Az elst y-nal jelltk a matematikai analgia miatt vagyis a fggvnyrtkeket dupla pontossg lebegpontos szmknt meghatroz tagfggvnyt. A tagfggvny minstse publikus, teht ms osztlyokbl elrhet. A msik metdus a toString. Ez a metdus a fggvny rtket jl
olvashat szveges formban szolgltatja. (Valjban ez egy felldefinilt
metdus, rszletesen az rkldss trgyalsakor elemezzk.)
4.1.1. Osztlyok betltse a virtulis gpbe
Eddig az osztly definilsval foglalkoztunk. Egy osztly a fordtsa utn

lesz felhasznlhat, azaz a virtulis gpbe betlthet. A virtulis gp egy
adott osztlyt akkor tlt be a memriba, amikor arra az els hivatkozs
megtrtnik (az interpreter jelleg miatt).
Azt az elz fejezetbl lthattuk, hogy egy program futtatst gy rhetjk el, hogy a virtulis gp indtsakor paramterben megadunk egy
olyan osztlyt, amelyiknek ltezik egy main metdusa (pl: java Teszt).
Ekkor ezt az osztlyt az interpreter betlti s a Java szabvnya szerint, a
main metdussal megkezdi az utastsok vgrehajtst.
Abban a pillanatban, amikor a futs odar egy objektum deklarcis
utastshoz, s ott egy addig mg nem hasznlt tpusazonostt tall,
azonnal megprblja betlteni az objektum tpusnak megfelel osztlyt a
virtulis gp memrijba.
Teglalap t1;
LinearisFuggveny lin1;
Amennyiben a Java krnyezet a CLASSPATH krnyezeti vltozban megadott knyvtrakban, vagy csomagokban ilyen nev osztlyt nem tall, a
program futsi hibval lell. (Az osztly megltt termszetesen fordtskor
is ellenrzi, s a hibt mr itt is jelzi; de elfordulhat extrm esetben, hogy
az elzleg lefordtott osztly class fjlja elrhetetlen, vagy trlve lett.)
A betlts sorn a virtulis gp inicializlja az osztlyban szerepl osztlyvltozkat s osztlyfggvnyeket (statikus adattagok s metdusok)
bvebben lsd az 4.5. Osztlyvltozk fejezetben, tovbb belltja a virtulis metdusok tblzatt (VMT). Amint az osztly betltse s inicializlsa megtrtnt, mr alkalmas a pldnyok ltrehozsra.
Vissza
79
Programozs III.
Vissza
80
4.1.2. A pldnyosts
A pldnyosts folyamatakor egy

t1 = new Teglalap(3,5);
alak hvskor a t1 referenciavltoz a new utasts hatsra pldnyt,

vagyis egy objektumra mutat referencit kap. A konstruktorhvs menete
a kvetkez:
A Teglalap t1; sor a t1 pldny deklarcija volt. A t1 azonostt
hasonlan az alaptpusokhoz Teglalap tpusnak deklarljuk. Itt mg
csak az azonost tpushoz rendelst vgeztk el, a t1 objektum mg
nem ltezik. A kvetkez sor a pldnyosts mvelete: a t1 = new
Teglalap(3,4); utasts hatsra a rendszer a Teglalap osztly kt
egsz paramterrel rendelkez konstruktort megkeresi, s meghvja az
aktulis (3,4) paramterekkel. A konstruktorhvs hatsra a memriban
megtrtnik a helyfoglals, s az adattagok megkapjk alaprtelmezett
rtkket. Ezutn a lefut a konstruktor trzse, s rendre vgrehajtja az ott
megadott utastsokat. (Esetnkben lsd 3.2.4. a tglalap oldalait belltja a paramterben tadott rtkekre.) A konstruktor trzsnek vgrehajtsa utn mr rendelkeznk egy objektummal, de ekkor az objektumnak
mg nincs semmi kapcsolata az azonostval. Ekkor a t1-hez teht
hozzreneli az objektum cmt, s ettl a ponttl fogva az objektumunk
mr pontosan definiltnak tekinthet. Mivel a t1 azonost referencia
tpus, ezrt innentl kezdve a . opertor segtsgvel a metdusai elrhetk, vagyis az objektumnak mr kldhet zenet.
A referencia tpus vltozk deklarcijt kzvetlenl kvetnie kell a
konstruktorhvsnak, mert a csupn deklarlt vltozt mg nem rendeltk
egyetlen objektumhoz sem, gy a referenciaazonost null rtk. Ha egy
null rtk referencia metdust kvnjuk elrni, akkor futsidej hibt
kapunk (NullPointerException). Ennek a hibnak az elkerlse vgett
clszer a tmrebb defincis-pldnyost utastst hasznlni:
LinearisFuggveny lin1 = new LinearisFuggveny (2,-2);
4.1.3. A pldnyok s az osztlyok megszntetse
Az osztlyok s az objektumok mindaddig az operatv trban maradnak,

amg azokat hasznljuk. Mivel a Java nyelvben nincsenek destruktor metdusok, a memria felszabadtsnak terhe lekerlt a programoz vll-
Vissza
80
Programozs III.
Vissza
81
rl. A memria menedzselst a virtulis gp maga vgzi a felhasznl ell

elrejtve. A memria egyetlen egysget alkot, n. szemtgyjt mechanizmussal menedzselt dinamikus memriaterletknt rtelmezett (garbage
collected heap).
A virtulis gp minden betlttt osztlyt s minden egyes ltrehozott
objektumot, a hozz tartoz referencival nyilvntart. Amennyiben egy
objektumot mr nem hasznlunk s egyetlen referencia sem mutat az
adott memriaterletre (kilptnk az objektumot ltrehoz blokkbl, vagy
a referencijt null rtkre lltottuk stb.), onnantl a virtulis gp ezt a
terletet a szemtgyjts vgrehajtsig zrolja. Ugyangy, ha egy osztlyra
mr nincs szksg (mr nincs belle egyetlen pldnyostott objektum
sem), az osztly ltal lefoglalt terletet is szemtgyjts ltal felszabadthatnak jelli a virtulis gp.
A szemtgyjtst a virtulis gp ltalban akkor vgzi el, ha elfogy a
rendelkezsre ll memria, de explicit System.gc() hvssal a programbl is krhetjk (garbage collect). A szemtgyjts az elrhetetlen objektumokat felkeresi, s az ltaluk foglalt terleteket felszabadtja.
Megjegyzs: A szemtgyjt minden felszabadtand objektumon vgrehajtja a finalize() metdust (melyet az Object osztlybl rkl), illetve minden felszabadtand osztlyon a classFinalize() osztlymetdust, s csak ezutn trtnik meg a tnyleges memriafelszabadts.
4.2. rklds
Az objektumorientlt szemllet szerint egy adott osztlyt rkldssel
specializlhatunk. Az rklds legegyszerbb esete, amikor egy osztlyt
egy mr ltez osztly kiterjesztseknt definilunk. A kiterjeszts jelentheti j tulajdonsgok (adattagok), s j mveletek (metdusok) megjelenst. Az j, bvtett osztly (vagy ms nven leszrmazott) az s minden
adattagjval s metdusval rendelkezik, a definciban csak a megjelen
j adattagokat s metdusokat kell definilni. A Java nyelvben az rkldst az extends kulcsszval adjuk meg:
Vissza
81
Programozs III.
Vissza
82
public class Alkalmazott{

protected String nev;
protected int fizetes;
public Alkalmazott (String nev_, int fizetes_){
nev =nev_;
fizetes = fizetes_;
}
public void fizetesEmeles(int mennyivel){
fizetes += mennyivel;
}
}
public class Fonok extends Alkalmazott{
private int potlek;
public Fonok (String nev_, int fizetes_, int potlek_){
nev =nev_;
fizetes = fizetes_;
potlek = potlek_;
}
public int gepkocsiHasznalat(){
return fizetes/10;
}
}
Az osztlydefinciban az extends kulcssz mgtti osztlynv jelzi,

hogy melyik osztlyt kvnjuk a bvteni.
A Java nyelv csak egyszeres rklst tmogat, teht az extends kulcssz mgtt kizrlag egyetlen, mr definilt osztly neve llhat. A ltrehozott leszrmazott osztly egy nll j osztly lesz, amely a definciban
megadott adattagok, s metdusokon kvl az s adatait, s metdusait is
tartalmazza. A leszrmazott osztlybl ugyangy hozhatunk ltre objektumokat, mint az sbl. Azonban a gyermek csak azokhoz az rklt tartalmakhoz frhet hozz, amelyeket a szl megenged (Lsd 3.2.7. fejezet
hozzfrsi kategrik). Ha nagyon szigor adatrejtst alkalmazunk, akkor
az adattagokat csak az sosztly metdusain keresztl rhetjk el:
Ha egy s privt adattagokat definil, akkor a leszrmazott kzvetlenl
nem frhet hozz ezekhez az adattagokhoz jllehet azok az objektum sajtjai csakis az sben definilt, ezeken az adattagokon manipull metdusokon keresztl hozzfrhetk. (Egy kzrthet pldval:
gondoljunk egy gyermek szljnl lv zsebpnzre, amely csak a
megfelel krsre lesz a gyermek szmra elrhet.).
Vissza
82
Programozs III.
Vissza
83
Az s flnyilvnos tagjaihoz a leszrmazott hozzfrhet, ha vele egy

csomagban van.
Az s vdett tagjaihoz a leszrmazott mindenkppen hozzfrhet, akr
ms csomagban is definilhatjuk a leszrmazottat.
Az s publikus metdusaihoz a leszrmazott ugyangy hozzfrhet,
mint brmilyen msik osztly.
Gyakori programozi hiba az rklsi lncokban publikus adattagokat
definilni, hiszen a programoz ideje drga, s nem kvn bajldni a
megfelel metdusok megrsval. Azonban ilyenkor az objektumorientlt
alapelvek alaposan srlnek, teht az gy elksztett program nem tekinthet objektumorientltnak!
A leszrmazott osztly az rklt adattagok s metdusokon kvl rendelkezik mg a sajt adattagjaival, metdusaival. gy a pldban a Fonok osztlyban a nev s a fizetes adattagokon kvl a potlek-kal, valamint a
fizetesEmeles metdus mellett a gepkocsiHasznalat metdussal is
rendelkezik. A metdusok kezelsben az s s a leszrmazott kztt
kdmegoszts jn ltre, hiszen a virtulis gp a kt osztly rklt metdusaihoz csak egyetlen kzs memriaterletet rendel.
A jl megtervezett rklsi hierarchia megtervezsvel a forrskdok
ttekinthetbb, hatkonyabb s knnyebben mdosthatv vlnak,
hiszen a redundns kdols elkerlhet.
4.2.1. A kzs s
A Java nyelvben ltezik egy kzs sosztly. Ha egy osztlyt definilunk s

nem adunk meg expliciten st, akkor automatikusan az Object osztly
leszrmazottjaknt jn ltre. Ez a kzs s a java.lang csomag rsze.
Ha a Java osztlyait, mint egy ft brzoljuk, akkor a fa gykrpontjban
ez az Object osztly ll.
Az Object osztly metdusait minden osztly rkli. A programoz
ezek kzl keveset hasznl (toString, getClass, equals), m a virtulis
gp annl tbbet. Ezek a metdusok kpezik a kapcsolatot az objektumok
s a virtulis gp kztt. Ilyen a mr emltett finalize()is, illetve a prhuzamos programok rsban nagy szerepet kap wait(), notify(), s
notifyall().
Vissza
83
Programozs III.
Vissza
84
A kzs s hasznlata azrt hatkony, mert a minden osztlyra s minden

pldnyra rtelmezhet alapvet mveleteket a nyelv gy csak egyszer definilja, s azt minden leszrmazottjra kiterjeszti.
4.2.2. A konstruktorok szerepe rkldskor
A konstruktorok nem rkldnek. Mint mr feljebb is lttuk a

konstruktornak az adott osztly pldnyostsban, s az objektumok inicializlsban van szerepe. Az rkldst pedig azrt hasznljuk, hogy az
adott osztlyt specializljuk, gy az esetek nagy rszben j adattagokkal
bvtjk. Az j adattagokat is illik inicializlni, ezrt j konstruktorra van
szksg. Ezrt a nyelv specifiklsakor a Java fejleszti gy jrtak el, hogy
az rklsbl kihagytk a konstruktorokat.
Vannak olyan esetek, amikor a szl konstruktornak hvsa szksges. Ezt a Java krnyezetben a super()metdushvssal rhetjk el.
super (nev_, fizetes_);
potlek = potlek_;
}
A szl konstruktornak meghvsa tbb szempontbl is clszer. Egyrszt cskkenthet a redundns kdok szma. A pldban ugyan csak kt
adattag szerepelt, de egy vals feladatban egy osztlynak az sszes rkldst beleszmtva rengeteg adattagja is lehet. Msrszt ha a szl adattagjai privt minstsek, akkor csak a super hvssal tudjuk ezeket az
ersen vdett adattagokat elrni.
A super() hvsnak mkdsi elve miatt meg kell elznie a
konstruktor tbbi utastst! A super() hvs folyamata a kvetkez:
A pldnyosts sorn az adott objektum trterlet kap.
Majd elkezdi vgrehajtani a konstruktorban megadott utastsokat.
Ha az els utasts egy super() hvs, akkor a pldnyvltoz inicializlsa eltt vgrehajtja az s megfelel konstruktort. (A super() hvsnak azrt kell els helyen llnia, mert elszr az stl rklt vltozkat kell inicializlni, s csak ezutn lehet a leszrmazott objektumhoz rendelni.)
Ezutn a vezrls visszatr a leszrmazotthoz, s a fennmarad utastsokat is vgrehajtja.
A paramterek nlkli konstruktort Osztly() alakban, alaprtelmezett konstruktornak nevezzk. Ha egy osztlyhoz nem definilunk egyet-
Vissza
84
Programozs III.
Vissza
85
len konstruktort sem, akkor a fordtprogram automatikusan elltja egy

alaprtelmezett konstruktorral. Az alaprtelmezett konstruktor a pldnyostskor meghvja s alaprtelmezett konstruktort. (Ha a fordt
egyetlen sben sem tall kifejtett alaprtelmezett konstruktort akkor a
kzs sosztly Object() konstruktora fog lefutni.)
Megjegyzs: A super kulcssznak van mg egy jelentse (a this-hez hasonlan). Ha egy leszrmazott osztlybl egy sosztly adattagjt kvnjuk
elrni s a hozzfrs engedlyezett akkor a super.adattag hivatkozssal megtehetjk azt.
4.3. Tbbalaksg
A tbbalaksggal, mint objektumorientlt alapfogalommal az elmleti
rszben mr megismerkedtnk. Most nzzk meg, hogy a Java nyelv milyen megoldst nyjt az alapelv megvalstshoz, vagyis ahhoz, hogy objektumaink s mveleteink polimorfikus mkdssel brjanak.
4.3.1. Tbbalaksg az objektumok kztt
A Java nyelv szigoran elrja minden vltozhoz a tpusossgot. Mind az

elemi tpusok, mind a referencik esetn egyrtelmen meg kell adnunk,
hogy az adott vltoz/objektum melyik tpushoz tartozik. Azonban lttuk,
hogy az alaptpusoknl ltezik az automatikus, illetve az explicit tpuskonverzi, vagyis egy vltoz rtkt egy vele kompatibilis tpusba konvertlhatjuk (Lsd: 3.2.6. fejezet.).
Ez a tpuskonverzi a referencia tpusok kztt is ltezik. Az automatikus konverzi segtsgvel hvhatjuk meg egy leszrmazott objektumhoz
az sben definilt metdust. Ilyenkor az adott objektumot a rendszer
automatikusan az s tpusra konvertlja, majd ez alapjn hvja meg a
megfelel metdust.
Ugyangy egy Alkalmazott tpus referencihoz egy Fonok tpus
objektumot is rendelhetnk (lsd: 4.2. fejezet). Az automatikus konverzi
itt is vgbemegy, mert az objektumhierarchiban a felette ll osztly
kompatibilis a leszrmazott tpussal (az rklds tulajdonsgai miatt, a
leszrmazott tpus tartalmazza az sosztlyban definilt adattagokat, illetve
metdusokat).
Vissza
85
Programozs III.
Vissza
86
Megjegyzs: A kompatibilits fordtva nem mkdik, azaz egy Fonok tpus referencia automatikusan nem rendelhet egy Alkalmazott objektumhoz, a fordt incompatible types hibazenettel lell.
Ezt a megoldst a Java programok sokszor alkalmazzk, mikor osztlyhierarchikat kell kapcsolatba hozni. Ekkor a hierarchia tetejn lev osztlyt, vagy interfszt kapcsoljuk hozz egy msik osztlyhoz. A hierarchin
belli automatikus konverzi segtsgvel a pldnyok mveletei elrhetek lesznek, tervezsk, nyilvntartsuk is tlthatbb lesz.
A java.util csomag Vector osztlya alaprtelmezetten Object tpus
referencikat trol egy dinamikus tmbben. Mivel az Object osztly minden ms osztly se, gy automatikus konverzi segtsgvel ez az osztly
alkalmas brmilyen pldny tartalmazsra. Ezt, mint kontner osztlyt
rszletesen trgyaljuk a ksbbiekben.
Explicit tpuskonverzit, vagy tpusknyszertst is alkalmazhatunk referencikra. Ha a fenti mdon egy s tpus referencihoz egy leszrmazott
tpus objektumot rendelnk, akkor csak az sben definilt metdusokat
rjk el, hiszen az s nem tud a leszrmazott mveleteirl.
Ekkor kt lehetsgnk van. Az els az, hogy tpusknyszertst alkalmazunk az objektum referencijra. A tpusknyszertst az alaptpusokhoz hasonlan megadhatjuk (LeszrmazottOsztly)referencia
alakban.
A msik megolds az, ha mr az s szmra is ismertt tesszk az
adott mveletet, melyet a leszrmazottakban felldefinilunk (esetleg
absztrakt osztlyok s metdusok, vagy interfszek hasznlatval).
4.3.2. Metdusok felldefinilsa
Egy osztly kiterjesztse, specializlsa ltalban szksgess teszi egyes

mveletek jrafogalmazst, hiszen a leszrmazott nagyon sokszor mskpp hajtja vgre az adott mveletet. Ezt hvjuk a metdusok felldefinilsnak (overriding).
Egy osztly felldefinil egy metdust akkor, ha az adott mveletet
rkln valamelyik stl, de az osztly sajt defincit is ad r.
Vissza
86
Programozs III.
Vissza
87
A LinearisFuggveny osztly y metdusa felldefinilja a

KonstansFuggveny osztly azonos szignatrj(lsd: 4.3.3. fejezet) metdust ahol y(x) a fggvny x helyen felvett rtkt jelli.
A KonstansFuggveny osztlyban az y metdust gy definiljuk,
hogy az egyszeren az objektum adattagjval trjen vissza (fggetlenl x
rtktl), azonban a lineris fggvnyek esetn ez a visszatrsi rtk mr
az ax+b kplet alapjn hatrozhat meg.
A leszrmazott osztlyban a super().metdus() alak hvssal hivatkozhatunk az sosztlyban definilt metdusra.
public class KonstansFuggveny {
protected double a;
public KonstansFggveny(double a_) {a=a_;}
public double y(double x) { return a;}
return "Konstans fggvny y="+a ;
}
}
public class LinearisFuggveny extends KonstansFuggveny {
protected double b;
public LinearisFggveny(double a_, double b_) {
a=a_; b=b_;
}
public double y(double x) {
return a*x+b;
}
return "Lineris fggvny y="+a+"*x+"+b ;
}
}
A pldban mg egy msik metduson keresztl is megfigyelhet a felldefinils. Az osztlyokban definilt toString() metdusokon ezt hasznljuk ki. A toString() metdust az Object osztly vezeti be. Szerepe
az, hogy az objektum referencihoz egy szveges megjegyzst, rtelmezst
fzznk. Ez a metdus az objektum.toString() hvssal rhet el.
A legtbb esetben azonban a toString()-et a virtulis gp automatikusan hvja. A Java nyelvben ezt a metdust gy definiltk, hogy amikor
egy objektum referencit olyan helyen hasznlunk, ahol azt Stringg kell
konvertlni, az automatikus konverzi ennek a metdusnak a vgrehajtsval fut le.
Vissza
87
Programozs III.
Vissza
88
Az albbi programrszletben ezt hasznljuk ki. A KonstansFuggveny

osztlybl pldnyostunk k1 nven. Ezutn a kiadott kt utastst a virtulis gp azonos mdon hajtja vgre. Vagyis eredmnyknt a szveges kimenetre ktszer kirja a Konstans fggvny y=4 zenetet.
KonstansFuggveny k1 = new KonstansFuggveny(4);
System.out.println(k1.toString());
System.out.println(k1);
A metdusok felldefinilsnak fontos szablya, hogy az j metdusnak

az sben definilttal kompatibilisnek kell lennie. Ez azt jelenti, hogy:
a metdus neve, paramtereinek tpusa s szma (szignatra), s a viszszatrsi tpusnak meg kell egyeznie;
az j metdus hozzfrsi kategrija nem lehet szkebb a felldefiniland metdusnl;
az j metdus csak olyan kivteleket vlthat ki, amilyeneket az eredeti
is kivlthat. (A kivtelkezelsrl a 6.6. fejezetben lesz sz.)
A polimorfizmus sarokpontja a ksi ktsnek nevezett objektumorientlt
alapelv hatkony mkdse (futs alatti kts, dinamikus kts). Ahogy
azt az elmleti rszben is lttuk, az egyes objektumoknak ismernie kell a
sajt mveleteit. Ahhoz, hogy a futs alatti kts hatkonyam mkdjn, a
metdusokat nem szabad direkt mdon szorosan az osztlyhoz kapcsolni
(fordtsi idben), hanem valamilyen technikval az egyes pldnyokhoz
kell rendelni. gy az adott objektum mveleteit a virtulis gp minden
esetben elri.
A Java nyelvben a tisztn objektumorientlt jelleg miatt egy osztly
minden metdust virtulisnak tekintnk, vagyis minden metdust alaprtelmezs szerint dinamikus ktssel rendelnk az egyes objektumokhoz.
Ezt a Java egy rejtett szolgltatsa vgzi (dynamic method dispatch), amely
minden egyes metdushvsnl megvizsglja, hogy az egy felldefinilt
vagy felltlttt metdusra rkezett-e. Ha igen, akkor azt a metdust keresi meg s hajtja vgre, amely az adott objektumhoz tartozik.
Megjegyzs: Minden esetben az objektum konstrukcijakor megkapott
(hozzrendelt) metdusokat hajtja vgre, mg akkor is, ha az automatikus
konverzi kihasznlsval, egy s tpus referencival hivatkozunk a pldnyra.
Vissza
88
Programozs III.
Vissza
89
A final mdost segtsgvel lehetsgnk van egy osztlyt, vagy metdust vglegesnek tekinteni. A final kulcssz hasznlata utn egy osztlyt
mr nem lehet leszrmaztatni, illetve a metdust nem lehet felldefinilni.
gy elrhet, hogy egy metdus a leszrmazott osztlyokban is garantltan
ugyangy hajtdjon vgre. (Ilyen pldul az Object osztly getClass()
metdusa, amely az adott pldnyt ler dinamikus osztlytpust hatrozza
meg. Mivel ennek megvltoztatsa az egsz Java krnyezetre kihatssal
lenne, ezrt vglegestettk.)
4.3.3. Metdusok felltltse
Sok programozsi nyelv az egyes fggvnyeket, metdusokat csak a nevk

alapjn azonostja, gy a hasonl mveletekhez eltr azonostkat kell
rendelnnk. A Java nyelvben azonban az egyes metdusokat az n. szignatra azonost. A szignatra a metdus nevbl, paramtereinek tpusbl
s szmbl ll. Az gy specifiklt azonost kpzsi szably nagyobb szabadsgot ad a programozk kezbe. A hasonl mveleteket azonos nvvel, de eltr paramterezssel hasznlhatjuk, s a magasabb szinten megfogalmazott mveleteket knnyebben implementlhatjuk a nyelvben.
Ezt a technikt a metdusok felltltsnek (overloading) nevezzk.
public class Fonok {
private String nev;
private int fizetes, potlek;
nev= nev_; fizetes = fizetes_;
potlek = potlek_;
}
public void fizetesEmeles(int emeles_){
fizetes += emeles_;
}
public void fizetesEmeles(int emeles_, int potlek_){
fizetes += emeles_;
potlek += potlek_
}
A pldban a fizetesEmeles metdusra adtunk ktfajta rtelmezst.

Ezutn egy pldny az azonos zenetre a fnk fizetsemelst kap ktflekppen reaglhat. A hvs utn a futs idej kts miatt a paramterezstl fggen a megfelel utastssorozat kerl vgrehajtsra.
Vissza
89
Programozs III.
Vissza
90
Fonok fonok1 = new Fonok(Bla, 100000, 5000);

fonok1.fizetesEmeles(25000);
fonok1.fizetesEmeles(25000, 1000);
A felltlttt metdusok kivlasztsa elmleti szinten, ha tbb felldefinilt s felltlttt metdus is szerepel nem teljesen egyrtelm folyamat. A Java minden esetben, a dinamikus metdushvs miatt, a hvs
helyn az aktulis paramterek tpusa szerinti legjobban illeszked metdust hvja meg.
Nagyon gyakran elfordul, hogy egy osztlyban felltlttt konstruktorokat hasznlunk. A hasznlat oka a pldnyosts folyamatnak ltalnos rtelmezse. Gyakran kell ugyanis egy objektumot klnfle rtkekbl ltrehozni, de elfordulhat olyan eset is, amikor a ltrehozs pillanatban mg nem ismert minden szksges adat.
Ha pldul egy osztlyban trtszmokat szeretnnk kezelni, akkor a pldnyostsnak tbb felltlttt metdusdefincit is adhatunk:
public class Tort{
private int a,b;
public
a =
}
public
a =
}
public
a =
}
public
a =
}
Tort(){
0; b = 1;
//szmll s nevez
//alaprtelmezett konstruktor
Tort(int a_){
a_; b = 1;
Tort(int a_, int b_){
a_; b = b_;
Tort(Tort t){
t.a ; b = t.b;
// msol konstruktor
A paramterek nlkli Tort() alak konstruktort alaprtelmezett

konstruktornak nevezzk (default constructor). Hvskor nem fogad paramtereket, gy valamilyen alaprtelmezett rtkekkel ltjuk el a pldnyt.
A msodik konstruktor segtsgvel egsz szmokbl kpezhetnk trteket, pl. a Tort(3) alak konstruktorhvssal. A harmadik esetben egy trt
szmlljbl s nevezjbl kpezzk az objektumot a Tort(3,4) hvssal.
Vissza
90
Programozs III.
Vissza
91
Az negyedik konstruktor definci a ltrehozand osztly egy pldnyn keresztl hoz ltre j objektumot. Ezt ms nven msol konstruktornak is nevezzk (copy constructor).
Megjegyzs: Emltettk, hogy ha egy osztlyban nem definilunk egyetlen
konstruktort sem, akkor a fordt elltja alaprtelmezett konstruktorral.
Ha azonban megadunk legalbb egy sajt konstruktort, akkor nem kerl
befordtsra az alaprtelmezett konstruktor.
A this kulcsz trgyalsakor emltettk (lsd: 3.2.4.), hogy fontos szerepe
lesz a konstruktoroknl. A konstruktordefinci els utastsban a
this() hvssal hivatkozhatunk egy elzleg mr definilt konstruktorra. A this() hvs hasznlatval a defincit visszavezethetjk egy mr
definilt mveletre, gy cskkenthet a kd redundancija, hiszen a felltlttt konstruktorok hasonl mveleteket hajtanak vgre, kisebb mdostsokkal. Az elz pldt akr gy is definilhatjuk:
public
public
public
public
Tort(int a_, int b_){a = a_; b = b_;}

Tort()
{ this(0,1); }
Tort(int a_) { this(a_,1); }
Tort(Tort t) { this(t.a,t.b); }}
4.3.4. A metdushvs folyamata az rklsi lncban
Ha elksztnk egy osztlyhierarchit, akkor a metdusokat ltalban a

mvelet els elfordulsi szintjn definiljuk. Ha egy leszrmazott osztlyt
pldnyostunk, akkor az, az rkldsben trgyalt szablyok szerint elrheti azokat. A metdushvs helyessgt mr a fordt ellenrzi, hiszen
egy objektum csak olyan metdusra hivatkozhat, amelyikkel kapcsolatban
ll, de ennek eldntse a kezd programoz szmra nem mindig egyrtelm. A futs sorn a metdushvst a virtulis gp a kvetkez mechanizmussal hajtja vgre: ha az adott osztlyban tall olyan szignatrj metdust, akkor azt vgrehajtja, ha ilyen nincs, akkor megkeresi a legkzelebbi sben.
Vissza
91
Programozs III.
Vissza
92
17. bra: A metdushvs folyamata az rklsi lncban

Felltlttt, illetve vegyesen felltlttt s felldefinilt metdusok esetn
a hvsnak megfelel szignatrj metdust keresi meg s hajtja vgre.
Abban az esetben, ha egy metdust az adott rklsi gon valahol felldefiniltunk, akkor a hvs helyhez legkzelebb es metdus kerl
vgrehajtsra. Vagyis a vezrls csak addig lpdel felfel a hierarchin,
amg a defincit meg nem tallja.
4.3.5. A rekurzi
Egy osztlyban definilt metdus termszetesen meghvhat ms metdusokat. Abban az esetben, ha egy metdus nmagt hvja, rekurzv metdushvsrl beszlnk. A rekurzi a hagyomnyos programnyelvekben
hasznlt rekurzv mkdshez hasonlan hasznlhat. Egyszer s knynyen ttekinthet kdot ad, de ugyangy lassabb s erforrs ignyes a
vgrehajtsa (a paramtereknek s a loklis vltozknak minden egyes
hvskor trhelyet kell foglalni).
Vissza
92
Programozs III.
Vissza
93
Ksztsnk egy egyszerusites() fggvnyt, amely kt szm hnyadost

egy rekurzv legnagyobb kzs osztt meghatroz lnko(a,b) fggvnynyel egyszerbb alakra hozza:
private void egyszerusites(){
if (b<0){ a=-a; b=-b;}
if (a==0) b=1;
else {
int o= lnko(Math.abs(a), b);
a/=o;
b/=o;
}
}
//rekurzv legnagyobb kzs oszt szmts
private int lnko(int x, int y){
if(x%y!=0) return lnko(y, x%y);
else return y;
}
Az egyszersts a trt szmlljt s nevezjt a kt szm legnagyobb

kzs osztjval osztja. Ehhez egy olyan rekurzv fggvnyt hasznlunk
(lnko), amelyik kt pozitv egsz szmbl a maradkkpzs segtsgvel
ellltja a legnagyobb kzs osztt.
Ksztsnk el egy olyan Trtszmokat kezel osztlyt, amely kihasznlja a
felltlts adta lehetsgeket.
/**
* Tortszmokat bemutat pldaprogram
* overloading, felltlts, privt s nyilvnos metdusokkal
*/
public class Tort{
//szmll, nevez
private int a, b;
//felltlttt konstruktorok
public Tort(int a_, int b_){
a=a_ ;
b=b_;
egyszerusites();
}
public Tort(int a_ ) { this(a_, 1); }
public Tort() { this(0,1); }
public Tort(Tort t) { this(t.a, t.b);}
Vissza
93
Programozs III.
Vissza
94
94
//sajt metdusok def.

private void egyszerusites(){
if (b<0){ a=-a; b=-b;}
if (a==0) b=1;
else {
int o= lnko(Math.abs(a), b);
a/=o;
b/=o;
}
}
//rekurzv legnagyobb kzs oszt szmts
private static int lnko(int x, int y){
if(x%y!=0) return lnko(y, x%y);
else return y;
}
//nyilvnos metdusok
public String vegyesTort(){
return (b==1)? " "+a : ((a/b)+" + "+(a%b)+"/"+b);
}
public void szoroz(int i_, int j_) {
a*=i_;
b*=j_;
egyszerusites();
}
public void szoroz(int i_) {
szoroz(i_, 1);
}
public void szoroz(Tort t_) {
szoroz(t_.a, t_.b);
}
public void osztas(int i_) {
szoroz(1, i_);
}
public void osztas(Tort t_) {
szoroz(t_.b, t_.a);
}
public void hozzaadas(Tort t2) {
a=a*t2.b+t2.a*b;
b*=t2.b;
egyszerusites();
}
Vissza
Programozs III.
Vissza
95
public void kivonas(Tort t2) {

a=a*t2.b-t2.a*b;
b*=t2.b;
egyszerusites();
};
//... stb.
}
/* Tesztprogram */
public class TortTeszt{
// Trt pldnyok
public static void main(String[] args){
//Tort1 osztlybl pldnyostunk
Tort t1= new Tort(1,3);
Tort t2= new Tort(4,3);
System.out.println("Az els trt: "+t31.vegyesTort());
System.out.println("A msodik trt: "+t32.vegyesTort());
//mveletvgzs Trtek kztt,
//az eredmny t1-ben keletkezik
t1.osztas(t2);
System.out.println("Hnyadosuk: "+t1.vegyesTort());
}
}
4.4. Absztrakt osztlyok

Az rklds s a tbbalaksg nagyon fontos szempont az objektumorientlt modellek tervezsekor. Az sosztlyok kzs nevezre hozzk a
leszrmazott osztlyok mkdst, vagyis definiljk a kzs mveleteket
s megadjk a szabvnyos zenetek prototpusait. Ezzel egy egysgesen
kezelhet osztlyhierarchit adhatnak a programoz kezbe. Az osztlyhierarchia legtetejn szerepl osztlyok szerepe ltalban az, hogy a leszrmazottaknak elrja, hogy milyen zenetekre vlaszoljon. A leszrmazott
osztlyokbl ltrehozott pldnyok a keresd az st elvnek megfelelen
megkeresik a hozzjuk tartoz zenet vgrehajtsnak defincijt.
Sokszor azonban az osztlyszerkezet tetejn ll osztly a feladat
modellezsbl addan csak egy elmleti fogalom, vagyis csak teljesen
ltalnos fogalmakkal rhat le, azaz hinyoznak belle a konkrtumok.
Ha pldul skidomok terlett szeretnnk meghatrozni, akkor a skidom
terlete egy ltalnos rvny fogalom (absztrakt), hiszen kplettel csak
egyes konkrt alakzatok (tglalap, kr, hromszg) terlett tudjuk kiszmtani.
Vissza
95
Programozs III.
Vissza
96
Az ilyen ltalnos rvny osztlyokhoz absztrakt osztlyokat definilunk.

A Java nyelv az absztrakt osztlyok definilst a class kulcssz el rt
abstract mdostval oldja meg.
Az absztrakt osztlyokban s csakis itt megadhatunk absztrakt metdusokat is. Az absztrakt metdusok trzs nlkli metdus deklarcik.
A metdusokat a leszrmazott osztlyokban ktelez felldefinilni, megvalstani.
Az absztrakt metdust gy deklarljuk, hogy a metdust szintn elltjuk az abstract mdostval, s a metdus defincijt res utastssal
jelljk. (A kapcsoszrjelek helyn pontosvessz ll.)
public abstract class Sikidom {
public abstract double kerulet();
public abstract double terulet();
}
public class Teglalap extends Sikidom {
private double a, b;
public Teglalap (double a, double b) {
this.a = a;
this.b = b;
}
//az s absztrakt metdusainak felldefinilsa
public double kerulet() {
return 2*(a+b);
}
public double terulet() {
return a*b;
}
}
public class Kor extends Sikidom {
private double r;
public Kor (double r) {
this.r = r;
}
public double kerulet() {
return 2*r*Math.PI;
}
protected double terulet() {
return r*r*Math.PI;
}
}
Vissza
96
Programozs III.
Vissza
97
A Sikidom osztly egy absztraktknt definilt osztly kt absztrakt metdussal a kerlet s a terlet meghatrozsra. A kt leszrmazott osztlyban (Kor, Teglalap) ezeket a metdusokat felldefiniljuk, s konkrt
utastssal ltjuk el, hiszen a modell ezen a szintjn mr ismerjk a megfelel kpleteket.
Az absztrakt osztlyok csak abban klnbznek egy tlagos osztlytl,
hogy tartalmazhatnak trzs nlkli, absztrakt metdusokat. Mivel az
absztrakt metdusok csak a metdusok szignatrjt rgztik nem adnak
defincit ezrt az absztrakt osztlyok nem pldnyosthatk. (Termszetesen tartalmazhatnak rendes adattagokat s metdusokat is.)
Ha absztrakt osztlybl hoznnk ltre objektumokat, akkor azoknak
nem lehetne rvnyes zenetet kldeni, futs kzbeni hibkat idznnek
el, hiszen az absztrakt metdusok nem tartalmaznak utastsokat. (Az
absztrakt metdusok eltt nem hasznlhatjuk a private, static s a final
mdostkat.)
Az absztrakt osztlyok tartalmazhatnak egyb adattagokat s definilt
metdusokat is.
Az absztrakt osztlyok leszrmazottjai is lehetnek absztraktak, de az
osztlyhierarchit gy kell kialaktani, hogy legyen legalbb egy olyan osztly, amely az absztrakt metdusokat megvalstja.
Az absztrakt osztlyok hasznlata sorn elfordulhatnak tipikus programozi hibk.
A fordt nem engedi meg, hogy absztrakt osztlyokat pldnyostsunk, s a Sikidom is abstract; cannot be instantiated
hibazenetet adja.
A msik gyakori hibalehetsg, hogy a leszrmazott osztlyban nem
definiljuk az s absztrakt metdusait. Ekkor a Teglalap is not
abstract and does not override abstract method
kerulet() in Sikidom hibazenetet kapjuk, vagyis a fordt azt
zeni, hogy vagy a Teglalap osztlyt kell absztraktnak minsteni,
vagy meg kell adni a kerulet() metdus defincijt.
4.5. Osztlyvltozk s osztlymetdusok

Az osztlyok eddig megismert adattagjait pldnyvltozknak is hvhatjuk,
hiszen ezeknek a vltozkhoz minden egyes pldnynl kln trterlet
tartozik. Nha azonban szksgnk van olyan vltozkra s mveletekre,
amelyek az egsz osztlyra vonatkoznak. Az albbiakban megismerkednk
Vissza
97
Programozs III.
Vissza
98
az osztlyvltozkkal (class member) s az osztlymetdusokkal (class

method). Az osztlyvltozkat s metdusokat mg a statikus adattag s
statikus metdus nvvel is illethetjk. Hasznlatukhoz a static kulcsszt
hasznljuk.
4.5.1. Osztlyvltozk
Egy osztlyvltoz az egsz osztlyra vonatkoz rtket trol. Az osztlyvltozk az osztly minden pldnya szmra kzsek s elrhetk. Vagyis
az osztlyvltozk szmra pontosan egy trterletet rendel a virtulis gp.
Az albbi pldban egy cg alkalmazottai mindannyian 62 ves korukban
mennek nyugdjba. Mivel ez a tulajdonsg minden egyes pldnyra kzs,
osztlyvltozban definiljuk. gy a pldnyoknak nem kell kln-kln
trterletet foglalni ehhez az rtkhez.
private static int nyugdijKorhatr = 62;
private int eletkor;
public String nyugdijbaVonulas(){

return Nyugdjba vonuls
+(nyugdijKorhatar - eletkor)+ v mlva;
}
}
Az osztlyvltozk definilsi sorrendben kapnak kezdrtket. A kezdrtkads mr az osztly virtulis gpbe val betltsekor megtrtnik. (A
pldnyvltozk termszetesen a konstrukci sorn kapnak kezdrtket.)
Az osztlyvltozk kezdrtk adsnl a mr definilt osztlyvltozkat
felhasznlhatjuk, de a pldnyvltozkat nem! Az osztlyvltozkat ksbb az objektumok kezdrtkhez (pldnyvltozk) mr felhasznlhatjuk, hiszen addigra az rtkk mr definilt lesz.
Az osztlyvltozkat az osztly defincija kzben ugyangy rnk el,
mint pldnyvltozkat. Nagyon gyakori, hogy osztlyvltozkban konstans rtkeket trolunk. Ilyenkor a minsts static final, vagyis csak
egyszer kaphat kezdrtket a vltoz, amelynek rtke a futs sorn nem
vltoztathat meg. (Ebben az esetben nem srtjk meg az adatrejts elvt,
hiszen a vltoz vgleges, csak olvashat.)
Vissza
98
Programozs III.
Vissza
99
A konstansknt definilt vgleges osztlyvltozkat csupa nagybetvel

rjuk. A Java krnyezet megadsakor a lang csomagban tallhat Math
osztlyba gyjtttk a gyakori matematikai llandkat s fggvnyeket.
A Java API a rtkt a
public static final double PI = 3.14159265358979323;
osztlyvltozval definilja.
A publikus osztlyvltozkra Osztly.osztlyvltoz alakban is hivatkozhatunk, pl.: Math.PI . Ilyen statikus adattag pl. a System osztly
out adattagja is, amely alaprtelmezs szerint az opercis rendszer karakteres kimenett jelenti, gy ennek az osztlyvltoznak a felhasznlsval
tudunk a kpernyre karaktereket rni. (pl.: System.out.println().)
4.5.2. Osztlymetdusok
Az osztlymetdusok szerepe nagyban hasonlt az osztlyvltozkra.

Ahogyan egy norml metdus az egyes pldnyok adattagjain rtelmezett mveletet jelent, gy az osztlymetdusok az osztly egszre vonatkoz mveleteket jelentenek.
Egy osztlymetdus rtelemszeren csak az osztlyvltozkhoz frhet
hozz. Az egyes pldnyvltozk, vagy a this hasznlata fordtsi hibt
okoz. Az osztlymveletek fggetlenek az osztly egyes objektumaitl, az
osztly virtulis gpbe val betltse utn mr azonnal hvhatak, mieltt
mg egyetlen pldnyt is ltrehoztunk volna. Ezrt az osztlymetdusok
hvsa legtbbszr az Osztly.osztlymetdus() alakban trtnik.
(Termszetesen egy adott pldnyra is meghvhatjuk a mveletet objektum.osztlymetdus() alakban, de szemantikailag az elz megolds a
megfelelbb.)
A mr emltett Math osztly szmos mvelete osztlymetdusknt lett
definilva, hiszen a gyakran hasznlt szmtsi mdszereket, kpleteket gy
egyszeren rhetjk el. Pldul a ngyzetgykvonst az albbi osztlymetdus definilja:
public static double sqrt(double a){}
Ha ezt a mveletet hasznlni szeretnnk, akkor egy albbihoz hasonl

hvst adunk ki a programunkban:
double gyokketto = Math.sqrt(2);
Ha az Alkalmazott osztlyban a nyugdjkorhatrt meg szeretnnk vltoztatni, akkor azt egy osztlymetdusban tudjuk megtenni:
Vissza
99
Programozs III.
Vissza
100

//osztlyvltoz:
private static int nyugdijKorhatr = 62;
//osztlymetdusok:
public static void nyugdijKorhatarEmel(){
nyugdijKorhatr++;
}
public static void nyugdijKorhatarCsokk(){
nyugdijKorhatr--;
}
A main, mint osztlymetdus

A fentiekhez hasonl osztlymetdus a main is. Els programunkban
nem fejtettk ki, hogy a main metdus defincija mirt ilyen elre rgztett alak:
public static void main(String args[]) {}
A main osztlymetdus szolgl arra, hogy egy publikus osztly virtulis

gpbe val betltsekor elindulhasson, s a programunk belpsi pontja
legyen. Ehhez a metdusnak mr ismertnek kell lennie az osztly betltse
utn kzvetlenl, ezrt hasznlnunk kell a static mdostt.
A public mdost azrt ktelez, mert egy kls hvsrl van sz,
ms hozzfrs metdust nem tudnnk elindtani, a void pedig azt jelzi,
hogy a main vgrehajtsa utn nem ad vissza rtket a hvnak, vagyis a
virtulis gpnek.
A main osztlymetdus bemen paramtere egy sztringekbl ll
tmb, amely a hvskor a megadott parancssori paramtereket tartalmazza.
Azonban a Java nyelv a 0. indexszel mr az els valdi berkez paramtert ri el, s nem a programindt parancs nevt, mint a C, vagy a C++
nyelvben.
public class Peldaprogram {
if (args.length > 0){
for (int i = 0; i < args.length; i++)
System.out.println(args[i]);
} else {
System.out.println("Nincsenek paramterek!");
}
}
}
Vissza
100
Programozs III.
Vissza
101
18. bra: A parancssori paramterek hasznlata

4.5.3. Az osztlyvltozk s osztlymetdusok elfedse
Egy osztly leszrmaztatsa sorn lehetsgnk van az skben definilt

pldny vagy osztlyvltozkkal azonos nev vltozkat definilni. Ekkor
a leszrmazott osztly elfedi az s azonos nev adattagjait. Az elfedett
vltozkat a leszrmazott rkli, de kzvetlenl nem fr hozz, csak a
minstett super.adattag hvssal, vagy tpusknyszertssel.
Az 4.3. tbbalaksg fejezetben kifejtettk, hogy a metdusok felldefinilhatk. Az osztylmetdusok trgyalsakor pontostanunk kell ezt a
kijelentst, hiszen csak a dinamikus kts pldnymetdusok definilhatak fell. Az osztlymetdusok esetn nem beszlnk polimorfizmusrl,
hiszen ezek a metdusok csak az adott osztlyra vonatkoznak.
Az osztlymetdusok esetn elfedsrl beszlnk. Egy osztlymetdus
elfedi az sben definilt, vele megegyez szignatrj metdusokat.
Az osztlymetdusok fordtsi idben trtn statikus ktssel rendeli
a fordt az osztlyhoz. Az osztlymetdusokat dinamikus kts (teht
nem static minsts) metdusokkal nem szabad elfedni! Az elfedsre
a felldefinilssal azonos korltozsok vonatkoznak (visszatrsi rtk,
kivtelek, hozzfrsi kategrik).
Vissza
101
Programozs III.
Vissza
102
4.6. Krdsek
Milyen szablyok vonatkoznak egy osztly definilsra a Java nyelvben?
Milyen hozzfrsi kategrikat adhatunk meg az egyes elemeknek?
Mit tudunk a virtulis gp trgazdlkodsrl?
Hogyan zajlik a pldnyosts folyamata?
Milyen kulcsszt hasznlunk az rklds jelzsre?
rkldnek-e a konstruktorok?
Mit jelent a super() hvs?
Mit jelent a szignatra sz?
Mit jelent egy metdus felldefinilsa?
Mit jelent egy metdus felltltse?
Hogyan tallja meg a virtulis gp az objektumhoz tartoz metdust?
Van-e lehetsgnk a Java nyelvben rekurzv metdust rni?
Hogyan definilunk absztrakt osztlyt?
Hogyan deklarlunk absztrakt metdust?
Mi trtnik, ha absztrakt osztlybl szeretnnk pldnyostani?
Hogyan definilunk osztlyvltozt, s osztlymetdust?
Mikor kell osztlyvltozt, ill. osztlymetdust hasznlnunk?
Az osztly pldnyai elrik az osztlyvltozkat? Ha igen, hogyan?
Az osztlymetdusok elrik a pldnyok adattagjait? Ha igen, hogyan?
Mit jelent a static final minsts?
Mikor beszlnk a vltozk elfedsrl?
4.7. Feladatok
Tervezze meg s ksztse el az albbi Java nyelv osztlyokat! gyeljen az
adatrejts betartsra!
Tglatest (a tglatestet a, b, c oldalval jellemezzk; definiljon
konstruktort, a tovbbi szmtand rtkek: felszn, trfogat).
Alkalmazott (nv, lakcm, havi fizets; metdusok: a szemlyi adatokat megjelent, s az ves fizetst kiszmt).
Henger (sugr, magassg, ill. felszn, trfogat) s Gmb (sugr, ill. felszn, trfogat).
Vissza
102
Programozs III.
Vissza
103
Ksztse el azt az rklsi szerkezetet, melyben egy Test sosztlybl

szrmaz Tglatest, Hasb, Henger, Gmb osztlyokat hasznlhatunk. A leszrmazott osztlyokban adja meg a felszn s a trfogat-szmtsi metdusokat.
Ksztsen egy fggetlen tesztel osztlyt, melynek main metdusban
a fenti osztlyokat pldnyostja, s rszletesen bemutatja (megfelel
szveges tjkoztatssal) az egyes metdusok mkdst.
Ksztsen egy absztrakt llatok osztlyt, amelyben egy lhely()
absztrakt metdust definil. Az osztly leszrmazottjai legyenek a Hzillatok s a Vadllatok. A leszrmazott osztlyban valstsa
meg felldefinilssal az absztrakt metdust. (Az osztlyok tetszleges
egyb tartalommal kiegszthetk.)
Ksztsen egy osztlyt a Tort osztlyhoz hasonl mdon a Komplex
szmok kezelsre (adattagok a vals s a kpzetes rsz) a megvalstand mveletek (felltltssel) sszads, kivons, szorzs s oszts
vals illetve komlex szmmal.
Az Alkalmazott osztlyban kezelje osztlytagknt a pldnyostott
objektumok szmt. Adjon meg osztlymetdusokat, amelyekkel az
objektumok szmt pontosan karbantarthatjuk. Mutassa be pldaprogramban a helyes mkdst.
Vissza
103
Programozs III.
Interfszek
Vissza
104
5. Interfszek
A Java alapvet ptelemeit az osztlyok jelentik. Az objektumorientlt
tervezsi s programozsi munka sorn a legtbbszr osztlyokkal dolgozunk. Az elzekben megismerkedtnk az absztrakt osztlyokkal, mint az
ltalnossgban megfogalmazott s konkrt pldnyokkal, kizrlag rktsi cllal ltrehozott osztlyok tpusval. Ilyen szerepet tltenek be a Java
nyelvben az interfszek is.
Az interfsz nem ms, mint az osztlyok egy olyan ltalnostsa, amely
csupn konstans rtkeket, s metdusok deklarcijt tartalmazhatja. (Az
absztrakt osztlyok mg tartalmazhattak vltoz jelleg adattagokat, s
definilt metdusokat is.)
Az interfsz csak egy felletet, kapcsoldsi pontot jelent, hiszen itt a mveletek prototpust adjuk meg, azaz egy szablyt, hogy milyen mveletet
akarunk az adott objektumon vgrehajtani. A modellezsben ezt a magasabb absztrakcis szintet mr elvonatkoztathatjuk minden konkrt adattl,
vltoztl.
Az sszehasonltst pldul absztrakt mdon megadhatjuk gy, hogy ha
kt objektumot ssze akarok hasonltani, akkor azt egy logikai fggvnnyel
vgezzk. Az egyes konkrt osztlyokban pedig megadjuk az sszehasonlts szablyt, hogy milyen tnyleges adattagok, vagy ms jellemzk segtsgvel hasonltunk ssze kt objektumot. (Ha pldul szemlyeket hasonltunk ssze, akkor nv szerint, gpjrmveket pedig mondjuk tpusuk
szerint klnbztetnk meg stb.)
Ha egy adott adatszerkezetben rendezetten szeretnnk objektumokat trolni, akkor definilnunk kell a rendezsi szablyt (metdust). De ezt a
rendezsi szablyt ismernie kell majd annak az osztlynak is, amelyiknek a
pldnyait trolni szeretnnk (hiszen itt tudjuk megadni az sszehasonlts
kplett az egysgbe zrtsg s adatrejts miatt). Valahogy teht szinkronba kell hozni ezt a kt osztlyt, hogy azonos zenettel hvjk, illetve
hajtsk vgre a mveleteiket. Erre szolglnak az interfsz osztlyok, hiszen
itt csak a protokollt adjuk meg.
Vissza
104
Programozs III.
Interfszek
Vissza
105
Az interfszek tnyleges mkdse majd az azokat implementl

(megvalst) osztlyokon keresztl trtnik, gy az absztrakt modell
konkrt tartalmat kap.
Az interfsz referencia tpus, de kzvetlenl nem pldnyosthat.
Azonban nagyon gyakran hasznljuk, mint a tpusok sszekapcsolst
jelent hivatkozst.
Egy tmbben skidom tpus objektumokat szeretnnk trolni. A modellezsben a skidom tpus objektumokat konkrtan a tglalap, kr, hromszg stb. osztlyokbl pldnyostjuk. A tmb Java nyelvi tulajdonsga
miatt egyszerre csak egyfle tpus elemeket tartalmazhat, gy a trolst
csak kln kr, tglalap, hromszg tpus tmbbel lehetne megoldani.
Azonban ha a tmbt az interfsz tpusval deklarljuk, akkor az automatikus tpuskonverzi miatt a tmbelemek az interfszt implementl
osztly objektumai lehetnek.
Deklarlhatunk teht interfsz tpus azonostt, amely egy olyan osztly
egy pldnyra vonatkozik, amelyik azt az interfszt megvalstja. gy az
interfsz tpus brmelyik leszrmazott osztly pldnyhoz felhasznlhat.
5.1. Interfszek deklarcija
Az interfszeket az interface kulcssz segtsgvel deklarljuk, ahol az
interfsz neve valamilyen mellknv:
public interface Interfsznv {
final int KONSTANS = kezdrtk;
public boolean mvelet();
}
A java.lang csomag Comparable interfsze az egyes objektumok szszehasonltst teszi lehetv. Deklarcija nagyon egyszer:
public interface Comparable{
public int compareTo(Comparable o);
}
A Java nyelv nem engedi meg, hogy egy osztlynak tbb se legyen, de
megengedi egy, vagy tbb interfsz felhasznlst, megvalstst.
Az interfszek ltalban kt olyan osztlyt ktnek ssze logikailag, amelyeknek nem sok kze van egymshoz, mgis szeretnnk egy olyan kzsen
hasznlhat felletet megadni, amelyik mindkt osztlyban garantlja, hogy
Vissza
105
Programozs III.
Interfszek
Vissza
106
az adott mvelet hasonl mdon menjen vgbe. A rendezsek sorn pldul fontos szerepet jtszik az egyes objektumok sszehasonltsa.
5.2. Interfszek kifejtse, megvalstsa
Egy osztly megvalst egy interfszt, ha az osztlydefinciban az
implements kulcsszval bejelentett interfsz metdusaira defincit ad.
public class Osztly implements Interfsz;
public class Osztly extends s implements Interfsz;
public class Osztly extends s implements Intf1, Intf2;
Ha a fenti Comparable interfszt egy konkrt osztlyban kell megvalstani, akkor az albbi alakban lehet azt megtenni:
public class Osztly implements Comparable{
double d;
//az interfszben elrt metdus defincija:
public int compareTo(Comparable obj){
return ( this.d (Osztly)obj.d );
}
}
Ezzel a defincival mr az osztly felhasznlhat az olyan osztlyokban,

ahol a Comparable interfsszel valstjk meg a rendezshez szksges
objektumok sszehasonltst.
19. bra: Interfsz hasznlata
Vissza
106
Programozs III.
Interfszek
Vissza
107
Az brn lthat feladatban kt osztlyt szeretnnk elltni hasonl funkcikkal. Abban az esetben, ha a kt osztly egy-egy fggetlen leszrmazsi
lnc rsze, akkor a Java megszortsai miatt egy msodik st nem mr nem
rendelhetnk hozzjuk. A Madr, mint az llat osztly, illetve a Replgp, mint a Gp osztly leszrmazottja kt teljesen fggetlen rklsi
lncot jelent, mgis mind a kt osztlyban hasznlni szeretnnk a replsi
kpessgeket meghatroz mveleteket. Ehhez interfszt kell hasznlnunk. Az interfsz nevt itt mellknvi rtelemben hasznljuk (milyen?)!
Az interfszben deklarlt metdusfejeket az interfszt megvalst osztlyban fejtjk ki. gy elmondhatjuk, hogy a Madr is s a Replgp is
Repl (replni kpes).
/** A replni kpes llnyek/trgyak kzs interfsze*/
public interface Repulo {
public void felszall();
public void leszall();
public void repul();
}
public abstract class Eloleny{
private String nev;
public Eloleny(String nev_){ nev = nev_;}
public String getNeve(){ return nev;}
public abstract String taplalkozik();
}
public abstract class Gep{
private String nev;
public Gep(String nev_){nev = nev_;}
public String getNeve(){ return nev;}
public abstract String hasznalatiUtasitas();
}
public class RepuloGep extends Gep implements Repulo{
public RepuloGep(String nev_){
super(nev_);
}
public String hasznalatiUtasitas(){
return "A replgp lgi kzlekedsi eszkz.";
}
// az interfszben deklarlt metdusok kifejtse
public void felszall(){
System.out.println("A replgp a
kifutplyrl szll fel.");
}
Vissza
107
Programozs III.
Interfszek
Vissza
108
public void leszall(){

System.out.println("A replgp egy hossz
kifutplyra szll le, hosszan fkezve.");
}
public void repul(){
System.out.println("A replgp 10000m magasban
rnknt 800-900 kilmtert tesz meg.");
}
}
public class Madar extends Eloleny implements Repulo{
public Madar( String nev_){super (nev_);}
public String taplalkozik(){
return "A madarak rovarokkal, magokkal tpllkoznak.";
}
// az interfszben deklarlt metdusok kifejtse
public void felszall(){
System.out.println("A madarak sr
szrnycsapsokkal szllnak fel.");
}
public void leszall(){
System.out.println("A madarak a lehet
legkisebb helyre is le tudnak szllni");
}
public void repul(){
System.out.println("A madarak rnknt
20-100 kilmtert tesznek meg.");
}
}
public class Teszt{
public static void main(String args[]){
//pldnyosts
Madar galamb1 = new Madar("Galamb 12");
RepuloGep airbus1 = new RepuloGep("Airbus 340");
// majd a metdusok elrse
System.out.println("madar1 neve: "+ galamb1.getNeve());
galamb1.taplalkozik();
galamb1.felszall();
galamb1.repul();
galamb1.leszall();
Vissza
108
Programozs III.
Interfszek
Vissza
109
System.out.println("airbus1 neve: "+ airbus1.getNeve());

airbus1.hasznalatiUtasitas();
airbus1.felszall();
airbus1.repul();
airbus1.leszall();
}
}
Az interfszt implementl osztlynak definilnia, vagy sn keresztl

ismernie kell az adott metdust, gy egy interfsz egy osztlyhierarchiban tbbszr is implementlhat, nem okoz fordtsi hibt. (Olyan eset is
elfordulhat, hogy az sosztlyban mr szerepel egy, az interfszben deklarlt szignatrj metdus, ekkor az rkls miatt ismert metdust
nem kell jra definilnunk, de akr az osztlyban az s metdust fell is
definilhatjuk.)
Egy pldnyrl az instanceof opertorral tudjuk eldnteni, hogy az
adott osztlynak vagy sosztlynak pldnya-e, illetve, hogy az adott interfszt megvalstja-e.
objektum instanceof Osztly;
objektum instanceof Interfsz;
Interfszeket gyakran fogunk hasznlni a Java nyelvben (a java.util

csomagban) definilt kontner osztlyokban, illetve szmos absztrakt modellel lert feladat megoldsa sorn.
5.3. Interfszek rkldse
Az interfszek rkldsi kapcsolatba is llhatnak. Ebben az esetben kiterjesztsrl beszlnk.
interface KiterjesztettInterfsz extends sInterfsz{}
Ekkor a kiterjesztett interfsz rkli az snek konstans tagjait, s metdusdeklarciit, illetve tartalmazza a sajt trzsben deklarltakat. Az ilyen
tpus interfszek megvalstsakor mind az s, mind a kiterjesztett interfsz metdusaira defincit kell adnunk, klnben a fordt a Osztly
is not abstract and does not override abstract method metdus(int) in Interfsznv hibazenettel jelzi, hogy az implemen-
tl osztlynak ki kell fejtenie a metdust (vagy az osztlyt absztraktnak

kell minsteni).
Vissza
109
Programozs III.
Interfszek
Vissza
110
5.4. Bels osztlyok

A bels vagy begyazott osztlyon egy osztlyon, vagy interfszen bell
definilt msik osztlyt, vagy interfszt rtnk. A tbbi osztlyhoz hasonlan egy bels osztlynak is lehet lthatsga (publikus, vdett, csomagszint, vagy privt). A bels osztlyok elhelyezsnek ktfle megvalstst szoktuk megklnbztetni: statikus, vagy dinamikus.
Ha egy osztlyt utastsblokkon bell hozunk ltre, akkor loklis osztlyrl beszlnk. Nvtelen osztlyok pedig akkor keletkeznek, amikor egy
mr ltez osztlyt a pldnyosts sorn j mveletekkel ltunk el. (A
bels osztlyok mlyebb s tfogbb tanulmnyozshoz [Nyky01] megfelel fejezeteit ajnlom.)
5.4.1. Tagosztlyok
A tagosztlyok olyan osztlyok defincijt jelenti, amelyeket egy osztly

adattagjai s metdusai kifejtse kztt, mint az osztly egy jabb tagjt
definiljuk.
class KlsOsztly {
<minsts> class BelsOsztly {
}
}
Statikus tagosztlyok
A statikus s dinamikus deklarci lesen elklnl egymstl. Statikus
esetben azt hasznljuk ki, hogy egy begyazott, statikus minsts osztly
elrejthet a klvilg ell, annak ltezsrl csak a tartalmaz tud. A statikus bels osztlyok szoros kapcsolatban vannak a tartalmaz osztllyal. A
kls osztly metdusai hozzfrnek a statikus tagosztlyok privt tagjaihoz, gy a bels osztly tagjainl szerepl minstsek csak a klvilgnak
szlnak. Magnak a bels osztlynak a minstse (public, protected,
private) megengedett, lthatsga gy szablyozhat. A statikus tagosztly definilsa esetn maga a definci fggetlen a tartalmaz osztlytl.
A Lista osztlyt egy ktirny lncolt lista megvalstsra szeretnnk
definilni. A lista minden elemt a privt Elem bels statikus osztly pldnyaknt definiljuk. Az Elem osztly nllan ltezik a List-tl fggetlenl, de a klvilg ell rejtve marad. Kezdetben res listbl indulunk
ki, majd a beszur metdussal tudunk jabb elemeket a listba felvenni.
Vissza
110
Programozs III.
Interfszek
class Lista{
private Elem elso;
Vissza
111
// Bels osztly adattag
private static class Elem {

// statikus bels osztly
private Object adat;
private Elem elozo, kovetkezo;
Elem (Object adat, Elem elozo, Elem kovetkezo){
this.adat = adat;
this.elozo = elozo;
this.kovetkezo = kovetkezo;
}
}// bels osztly vge
public void beszur(Object adat){
// beszrs a listba
elso = new Elem(adat, null, elso);
if(elso.kovetkezo != null){
elso.kovetkezo.elozo = elso;
}
}
public Lista(){}
//A tovbbi listakarbantart mveletek
}
public class ListaTeszt{
public static void main(String args[]){
// A listba sznt objektumok
Integer szam1 = new Integer(-4);
Double szam2 = new Double(3.15);
// A lista objektum ltrehozsa
Lista dinamikusLista = new Lista();
// Lista feltltse,
dinamikusLista.beszur("Indul a lista");
dinamikusLista.beszur(szam1);
dinamikusLista.beszur(szam2);
dinamikusLista.beszur(new Boolean (true));
// Lista kirsa
System.out.println(dinamikusLista);
}
}
A bels Elem osztly privt adattagjaihoz hozzfrhetnek a tartalmaz

osztly metdusai.
Megjegyzs: Bels osztlyknt interfszeket is deklarlhatunk.
Vissza
111
Programozs III.
Interfszek
Vissza
112
Nem statikus tagosztlyok

Ha egy bels osztlyt a fenti plda alapjn nem statikusnak adunk meg
(hinyzik a static kulcssz), akkor a bels osztly elrheti a tartalmaz
osztly privt adattagjait is. Ezt a KlsOsztlynv.this.adattag
minstett hvssal tehetjk meg. Itt mr rvnyeslnek a begyazs dinamikus jellegzetessgei is.
Megjegyzs: A nem statikus tagosztlyok pldnyostsakor elll bels
objektum(ok) a befoglal osztly adott pldnyhoz (befoglal pldny)
tartoznak. gy a bels osztly metdusaiban kt aktulis pldny is rtelmezve van. Az eredeti rtelemben vett elsdleges pldny mellett ott van
az aktulis pldny befoglal pldnya, mint msodlagos aktulis pldny.
A msodlagos aktulis pldny vltozira ugyangy hivatkozhatunk, mint
az elsdleges pldnyaira, s a befoglal osztly metdusait minsts nlkl is hvhatjuk a msodlagos aktulis pldnyra. Vagyis a nem statikus
tagosztly ltja s elrheti a befoglal pldny vltozit.
Egy bels osztlyt akkor hasznlunk nem statikus rtelemben, ha a kls
s a nem statikus tagosztly kztt 1:N kapcsolat ll fenn.
Egy nem statikus bels osztly egy pldnyt kvlrl a
belsoObjektum = kulsoObjektum.new BelsoOsztaly()
alak konstruktorhvssal hozzuk ltre.

5.4.2. Loklis osztlyok
A loklis osztlyok egy n. osztlydefinil utastssal definilt osztlyok.

rvnyessgk csak az ket tartalmaz blokkra terjednek ki, gy hozzfrsi minstst nem kaphatnak. A loklis osztly ltja a defincis pontjban elrhet vltozkat, m trzsben csak olyan final vltozkra hivatkozhatunk, amelyek mr kaptak kezdrtket. Ezt a korltozst azrt vezettk be, mert ezek az osztlyok a loklis vltozkrl msolatot ksztenek s az osztlyt tartalmaz blokkbl val kilps utn is megrzik rtkket, zrvnyok keletkeznek.
A loklis osztly ugyanazon szablyok szerint rheti el a tartalmaz
osztly tagjait, mint az elz rszben trgyalt statikus s nem statikus tagosztlyok.
Vissza
112
Programozs III.
Interfszek
Vissza
113
public void createLocalObject(final String e){

// konstans deklarci
final char f = 'f';
// az i vltoz nem lesz hasznlhat a loklis osztlyban!
int i = 0;
// Loklis osztly - egy blokkon bell definilt
// csak ebben a blokkban rtelmezett
class Local {
private char c = 'c';
public void printVars() {
System.out.println(c); // OK
System.out.println(e); // OK
System.out.println(f); // OK
System.out.println(i); // fordtsi hiba!
}
} //class Local vge
// Loklis osztly pldnyostsa
Local lokalispeldany = new Local();
// zenetklds a loklis pldnynak
lokalispeldany.printVars();
}
5.4.3. Nvtelen osztlyok
Sokszor szksgnk van olyan osztlyokra, amelyet csak egyszer hasznlunk, pldnyostunk. Ezeknek az osztlyoknak a defincijt a pldnyosts helyn is megadhatjuk. Az gy keletkez osztlyt nvtelen osztlynak
nevezzk. Megadsa gy trtnik, hogy a tartalmaz osztlybl egy j ideiglenes leszrmaztatst ksztnk, j metdusokkal gy hogy a tartalamz
osztly pldnyostsa sorn heyben megadjuk az j osztly defincijt.
new Osztly(paramterek) { osztlytrzs }
Adjon meg Osztaly-bl leszrmazott nvtelen osztlyt, amelyben definil

egy j metdust is!
//tetszleges blokkan:
Osztaly objektum = new Osztaly(){
// A nvtelen osztly trzse
public nevtelenEgyMetodusa() {
return szamitottErtek;
}
}
Vissza
113
Programozs III.
Interfszek
Vissza
114
5.5. Krdsek
Milyen clra hasznlunk interfszeket?

Interfsz trzsben milyen jelleg adatokat helyezhetnk el?
Minek tekinthetk az interfsz metdusai?
Lehet-e hasznlni az abstract mdostt interfszekben?
Mit neveznk az interfsz kifejtsnek (megvalstsnak)?
Interfszek kztt ltezik-e rklds?
Mire hasznlhatjuk a bels osztlyokat?
Mi jellemzi a Comparable interfszt, hol hasznlhat fel?
5.6. Feladatok
Definiljon egy Sikidom interfszt, amelyben deklarlja a kerlet s
terletszmtshoz szksges metdusokat, majd definiljon benne jellemz konstansokat. Alaktsa t a Kr, a Tglalap s a Hromszg
osztlyokat gy, hogy azok megvalstsk a Sikidom interfszt.
Ksztsen interfszt Hasonlithato nvvel (a Comparable mintjra),
s deklarljon egy mveletet, amely kt skidomot a terletk alapjn
sszehasonlt. Alaktsa t gy az elz feladatot, hogy a Kr, Tglalap s Hromszg osztlyok ezt az interfszt is megvalstjk!
Definiljon verem adatszerkezetet bels osztlyok segtsgvel, majd
lssa el karbantart mveletekkel.
Vissza
114
Programozs III.
Csomagok, komponensek
Vissza
115
6. Csomagok, komponensek
Egy nagyobb program elksztsekor trekednnk kell az ttekinthet,
knnyen mdosthat, s tovbbfejleszthet kd ellltsra. Ennek elrshez a programokat megfelelen tagolni kell. A tagolsnak mr az
objektumorientlt modellezs s a programtervezs szintjn meg kell nyilvnulnia. Az sszetartoz osztlyokat ezrt a modell s a mkds szerint csomagokba szervezzk. A Java osztlyknyvtrait is csomagokban,
jl tlthat szerkezetben definiltk. A csomagokbl kpezhet egy magas szint zrt egysg, ms szhasznlattal lve komponens.
Minden csomag egy nll nvteret (namespace) vezet be, amelyben
egyediv teszi a benne tallhat osztlyok szerkezett. A csomag alkalmas
a hozzfrsi kategrik kezelsre, s a csomagszint hozzfrsi kategrival definilt osztlyok, interfszek, metdusok csak a csomagon bell
lesznek elrhetek.
A csomagoknak nyelvi szinten a fordtsi egysgek(osztlyok,
intrfszek) adnak konkrt tartalmat. Egy csomaghoz tartoz fordtsi egysgben tallhat a csomag forrskdja. Ez a csomagszerkezet hierarchikus
hasonlan az llomnyok knyvtrszerkezetben val elhelyezshez
gy a csomagok kztt logikai al-flrendeltsgi viszony is elfordulhat.
Ekkor alcsomagnak nevezzk a csomagban tallhat msik csomagot.
Minden csomag tetszleges szm alcsomagot tartalmazhat.
6.1. A Java nyelv alapcsomagjai
A JDK csomagstruktrja kveti a fjlrendszerek knyvtrszerkezett, gy
a fcsomagok egy-egy klnll knyvtrban helyezkednek el, amelynek
alknyvtrai lesznek a fcsomagok alcsomagjai stb. A legfels szinten
helyezkedik el tbbek kztt a java csomag. Az egyes alcsomagokba tovbbi csomagokat, vagy osztlyokat s interfszeket tallunk. gy a java.lang csomag mint a nyelv alapcsomagja a nyelv alaposztlyait, a
mkdshez elengedhetelen osztlyok definciit tartalmazza, a java.io
csomag a fjlkezelshez szksges osztlydefincikat, a java.applet
csomag tartalmazza a hagyomnyos html oldalakba pl alkalmazsok
(appletek) lerst tartalmaz osztlyokat, a java.awt a grafikus alkalmazsok alaposztlyait tartalmazza stb.
Vissza
115
Programozs III.
Vissza
116
A Java2 megjelensekor 1999-ben, a nyelvet is bvteni kellett [1]. Erre

a javax csomag szolglt, amelynek alcsomagjai a megjelen j kdokat
tartalmaztk.
20. bra: A Java osztlystruktrja (rszlet)
Vissza
116
Programozs III.
Vissza
117
A Java csomagnevek tetszlegesek lehetnek, azonban a java, javax, vagy

sun kezdet csomagokba kizrlag a Sun szakemberei helyezhetnek csomagokat. A csomagnevek megktse tovbbra az is, hogy a ltrehozott j
csomagok nem tkzhetnek a Java API-ban megadottakkal.
A csomagok s osztlyok hasznlathoz az import kulcssz utn
megadott, . opertorral elvlasztott minstsek szolglnak. Ha pldul
az io csomag File osztlyt szeretnnk elrni, akkor azt a nvtrbe importlhatjuk a kvetkez utastssal:
import java.io.File;
Ha az io csomag minden osztlyra szksgnk van, akkor azt gy jelljk:

import java.io.*
A tovbbi bvtsi lehetsgeket, az interneten hasznlt URL hivatkozsokhoz hasonlan az egyes gyrtk ltal knlt osztlyokat is elrhetjk:
import com.sun.security.auth.*;
A csomagokat hagyomnyosan fjlrendszerben, egyes esetekben adatbzisokban is trolhatjuk. A fjlrendszerben trolt csomagok egy kiindul
knyvtrbl rhetek el. Ebbl a knyvtrbl, mint gykrbl kiindulva
adhatjuk meg az egyes alcsomagok knyvtrt, s ezzel prhuzamosan a
forrskdban a csomag elrst.
A Java forrsok vizsglatval a Java krnyezet alapknyvtrban tallhat src.zip fjlbl lthatjuk, hogy a Math osztly hivatkozsa java.lang.Math alak, s forrsa Math.java, amely a java/lang
knyvtrban tallhat. (A lefordtott osztlyok is ugyanezt a hierarchit
kvetik az rt.jar fjlban.)
A kialaktott osztlyszerkezet elrshez az opercis rendszerben
szksgnk van egy CLASSPATH nev krnyezeti vltozra, ahol a csomagok gykrpontjait rgztjk.
A Java krnyezet a CLASSPATH-ban megadott knyvtrak alapjn a
csomaghivatkozsokat elri. A CLASSPATH krnyezeti vltozhoz nem
csak knyvtrnevek, hanem csomag.zip s csomag.jar alakban
megadott fjlok is hozzfzhetk. Mivel a Java rendszert felksztettk a
tmrtett llomnyok feldolgozsra is, ezrt hozzadhat a .zip, vagy
az ugyanilyen tmrtsi algoritmust hasznl .jar fjl is. Sokszor megadjuk az aktulis knyvtrat jelent hivatkozst is: ..
Vissza
117
Programozs III.
Vissza
118
Az elrsi utat az albbi parancsokkal mdosthatjuk (Linux-Windows):

export CLASSPATH=
$CLASSPATH:/home/java/munka: /home/java/csomag.jar: .
SET CLASSPATH=
%CLASSPATH%;c:\java\munka;c:\java\csomag.jar;.
Egy Java csomag tpusdefincikat (osztlyok, interfszek forrsfjljait) s

tovbbi alcsomagokat tartalmazhat. Egy alcsomag nem kapcsoldik szorosan a hierarchiban felette llhoz, mivel a Java specifikci szerint a csomagok fggetlenek, legyenek azok egyms melletti, illetve egyms alatti
knyvtrban definilva. A hierarchikus szerkezet csak a modellezs folyamatt s a csomagok kztti logikus eligazodst segti.
6.2. A fordtsi egysg
A Java krnyezetben a fordtsi egysg az a hely, ahol a csomagok forrskdja megtallhat. Fjlrendszerben trolt csomagok esetn ez maga a
forrsfjl.
Egy fordtsi egysg a csomagdeklarcival kezddik, ezutn kvetkeznek a ms csomagokra vonatkoz importdeklarcik, majd a tpusdeklarcik.
package sajatcsomag;
import java.net.*;
public class Osztaly{
6.2.1. Nvtelen csomagok
Abban az esetben, ha a fordtsi egysg elejrl elhagyjuk a csomag deklarcit (package), akkor az egy n. nvtelen csomagba tartozik. Ez a nvtelen csomag azoknak a forrsfjloknak az sszessge, amelyek egy alknyvtrban helyezkednek el (jellemzen az opercis rendszer alaprtelmezett munkaknyvtrban). A nvtelen csomag csak nagyon egyszer
programokhoz, ltalban ideiglenes, vagy tesztosztlyok fejlesztshez
hasznlhat. A nvtelen csomaban nem deklarlhatunk alcsomagokat. Egy
sszetett alkalmazs esetn, a nvtelen csomagokkal elvesztjk a
modularits adta elnyket s a program tlthatsga is ersen romlik,
hiszem minden osztlyt fizikailag egy knyvtrban kell trolnunk.
Vissza
118
Programozs III.
Vissza
119
6.3. Csomagok deklarcija

Minden fordtsi egysg elejn deklarlhatjuk, hogy az melyik csomaghoz
tartozik. A csomagdeklarcit a package kulcssz vezeti be s a csomag
neve kveti, (pl: package sikidom;).
A package kulcssz csak a fordtsi egysg legelejn llhat, s egy
fordtsi egysgben csak egyetlen ilyen deklarci lehet! A csomagnv a
Java kdolsi konvencik ajnlsa alapjn [6] egy csupa kisbetkbl ll
azonost lehet.
Egy csomag szabadon bvthet jabb elemekkel, gy egy fordtsi
egysg, (osztly, vagy interfsz) egyszeren azltal, hogy egy csomag nevt
deklarlja, automatikusan a csomag rszv vlik.
Ha a CLASSPATH krnyezeti vltozban meghatrozott knyvtrban
vagyunk akkor a fenti csomagdeklarcival elltott fordtsi egysgeket az
ugyanolyan nev knyvtrban kell elhelyeznnk. (A fenti plda forrsllomnya a sikidom knyvtrba kerl.)
Ha a csomagnv sszetett, pl. package csomag1.csomag2.csomag3;
alak, akkor rtelemszeren a /csomag1/csomag2/csomag3 knyvtrba
kell elhelyezni, klnben a virtulis gp a hivatkozott osztlyokat nem tallja
meg.
6.4. Csomagok importlsa
A fordtsi egysgek csomagdeklarcija utn kvetkezhetnek az import
deklarcik. Minden egyes Java osztly a tartalmaz csomag nevvel s
az osztly nevvel magadott n. minstett nvvel hivatkozhat, pl:
java.util.Vector. Azonban a fejleszts hetkonyabb ttelhez, s a
minstett nevek sorozatos kirsa helyett az osztlyokra rvid nevekkel
clszer hivatkozni. (Ez nagymrtkben javtja a forrskd ttekinthetsgt is.)
Az import deklarci valjban nem ms, mint a ms csomagokban deklarlt publikus tpusok egyszer nvvel trtn elrsnek lehetsge a minstett nevek helyett.
import
import
import
import
import
sikidom.Teglalap;
sikidom.*;
java.util.*;
java.util.zip.Zipfile
com.sun.security.auth.login.ConfigFile
Vissza
119
Programozs III.
Vissza
120
Az import deklarci kt alakban hasznlhat. Az els esetben a sikidom

csomag egyetlen osztlyt importltuk, a msodik esetben pedig mindegyiket.
A harmadik esetben a java csomag util alcsomagjnak sszes tpust (osztlyok, interfszek) importltuk. Ez az importls nem jelenti egy
adott csomag alcsomagjainak automatikus importlst (a mvelet nem
rekurzv), mert mint az elz fejezetben lttuk, az alcsomagok nem ismerik egymst, s nem ismerik a felettk, vagy alattuk elhelyezked csomagokat sem, gy a negyedik sorban lev zip alcsomag Zipfile osztlyra
val hivatkozst kln meg kell adnunk.
Az import deklarci a csomagon bell csak az adott fordtsi egysgben rtelmezett, vagyis ha msik egysgben is hasznlni szeretnnk azt a
tpust, akkor ott jra importlni kell.
Megjegyzs: Az importls nem jelenti a fordtsi egysgek megnyitst s
a forrskd bemsolst, (teht lnyegesen klnbzik a C nyelv #include
direktvjtl) csak a tpusok rvid nvvel val elrsre szolgl.
A fenti pldban tallhat importlsok utn az osztlynevek megadsa a
kvetkez minstett nevek megadst eredmnyezik:
Teglalap
Vector
Zipfile
ConfigFile
sikidom.Teglalap
java.util.Vector
java.util.Zipfile
com.sun.security.auth.login.ConfigFile
6.5. A jar fjlok hasznlata

Egy csomagot a Java keretrendszer rszt kpez jar Java Archive segdalkalmazs segtsgvel (/bin/jar, jar.exe) tmrtve trolhatjuk, ksbbi fejlesztsekben komponensknt felhasznlhatjuk. A jar fjlok tmrtsi technikja megegyezik a zip llomnyok tmrtsi algoritmusval.
Egy jar fjlban az egymsba gyazott csomagok egy egysgknt, (modulknt, komponensknt) kezelhetek. A komponenst a CLASSPATH
krnyezeti vltozba bejelentve a tbbi csomag szmra elrhet s hivatkozhat lesz.
Ezen fell a jar fjl szmra megadhat az n. manifest fjllal, ami a
jar fjl lerja egy olyan osztlya is, amelyik belpsi pontknt szolgl,
gy egy modul a virtulis gpbe betltve nllan is futtathat (amennyiben van egy public static void main() osztlyfggvnye).
Vissza
120
Programozs III.
Vissza
121
Egy jar fjl lerst a Manifest.mf fjlban talljuk:

-Manifest-Version: 1.0
-Created-By: 1.5.0 (Szchenyi Istvn Egyetem)
-Main-Class: Teszt
A Main-Class bejegyzsben adhat meg a belpsi pont,azaz a fenti plda szerint a jar fjl betltsekor a publikus "Teszt" osztly main osztlymetdusval elkezddik a program vgrehajtsa.
6.5.1. Jar fjl ksztse
A .jar fjlok elksztst a jar segdprogram megfelelen paramterezett hvsval kezdemnyezhetjk. Az aktulis knyvtrban (ahol a csomagot kszteni szeretnnk) az albbi paranccsal indthatjuk a modulptst:
jar cvfm sajatcsomag.jar Manifest.mf .
ahol az albbi kapcsolkat hasznltuk:

c
v
f
m
.
create, j fjl ksztse

verbose, azaz beszdes kimenet
az elll .jar fjl neve
a Manifest fjl neve
a csomagolni kvnt knyvtr neve
Ezutn a sajatcsomag.jar nven elll modult futtathatjuk, vagy felhasznlhatjuk a tovbbi fejlesztshez. (A jar segdprogramnak mg szmos, itt nem trgyalt funkcija s lehetsge van.)
Megjegyzs: A manifest fjl szintaktikja elrja, hogy minden sora, gy az
utols utn is legyen soremels, klnben a jar csomagol ezt nem veszi
figyelembe!
6.5.2. Jar fjl futtatsa
Egy jar fjl, amely tartalmaz egy olyan publikus osztlyt, amelynek van
main osztlymetdusa s ezt a manifest fjlban is megadtuk, az albbi
paranccsal futtathat:
java -jar sajatcsomag.jar
Emltettk mr, hogy a CLASSPATH krnyezeti vltozban nemcsak

knyvtrakra, hanem .jar, vagy .zip llomnyokra is hivatkozhatunk.
Vissza
121
Programozs III.
Vissza
122
Teht, ha egy ksz modult (komponenst) jra fel akarunk hasznlni,

akkor a CLASSPATH krnyezeti vltozban megadjuk a komponens jar
fjljnak abszolt elrsi tjt:
export CLASSPATH=$CLASSPATH:/home/munka/sajatcsomag.jar
SET CLASSPATH=%CLASSPATH%;c:\munka\sajatcsomag.jar
Ezutn az egyes fordtsi egysgekben (forrsprogramokban) a modul

csomagjai elrhetk, a definilt osztlyok s interfszek importlhatk,
hivatkozhatk.
Egyedi esetben a virtulis gp indtsakor explicit mdon is megadhatjuk a CLASSPATH rtkt a -cp kapcsolval:
java -jar -cp /home/munka/egyikcsomag.jar masikcsomag.jar
6.6. Krdsek
Milyen clra hasznljuk a csomagokat?

Hogyan kell egy csomagot bejelenteni a forrskdban?
Mire hasznljuk a CLASSPATH rendszervltozt?
Mire hasznlhatak a jar fjlok?
6.7. Feladatok
Egy tetszleges, elzekben kidolgozott feladathoz (lsd: 3.4, 4.7, 5.6.
fejezet) ksztsen egy csomagot, majd a csomag osztlyaibl s a bemutat programbl lltson el futtathat .jar llomnyt.
a logikailag sszetartoz osztlyok egy knyvtrban legyenek,
a bemutat program egy szinttel ezen knyvtr fltt helyezkedjenek el.
Vissza
122
Programozs III.
Kivtelkezels
Vissza
123
7. Kivtelkezels
A programozsi munka sorn ltalban a helyes hasznlatnak megfelelen
ksztjk fel a programokat. A mkds sorn azonban elfordulhatnak
olyan, esetleg kivteles llapotok is (a helytelen hasznlatbl, valami kls
okbl, vagy programozsi figyelmetlensgbl ereden), amikor a program
hibsan mkdik.
A hagyomnyos programozsi technikkban a szubrutinok hibakdokkal jeleztk a vgrehajts helyessgt, illetve hibit. A Java nyelv ms
szemlletmddal kezeli a hibk elfordulst. A programkd kivteles
llapotba kerlsekor a virtulis gp egy kivtelt (exception) vlt ki. A
kivtelek olyan objektumok, amelyek egyes kivtel-osztlyokba sorolhatk.
A kivtel osztlyokat a Throwable osztly alosztlyaiknt definiltk. A
kivtel jelleg osztlyok kt csoportba sorolhatk:
Error (hiba): Az ilyen tpus kivtelek olyan alapvet hibkat jellnek,
amelyeknek azonnali programfuts lells az eredmnye, s nem kezelhetek le (pl: elfogy a memria).
Exception (kivtel): Ezek a fajta kivteles esemnyek a futs sorn
lekezelhetk. Ekkor a program normlis menete megszakad, s a vezrlst az elrt vezrlsi szerkezetekkel az aktulis hibt lekezelni hivatott programrszre irnythatjuk.
A kivtelkezels ersen pt a Java tipikusan objektumorientlt elemeire: A
futsi idben elll hiba hatsra egy objektum keletkezik, amely a hiba
fellpsnek krlmnyeit (a hiba tpust s a program aktulis llapott)
rja le, ezt a virtulis gp szleli s tadja egy, a kivtel feldolgozsra sznt
programrsznek, amely a kivtelobjektumba csomagolt informciknak
megfelelen gondoskodik a folytatsrl.
A kivtelek feldolgozsa szempontjbl megklnbztetnk ellenrztt s nem ellenrztt kivteleket. Azokat a kivteleket, amelyeket felttlenl fel kell dolgozni (azaz ktelez vagy specifiklni, vagy elkapni), ellenrztt kivtelnek nevezik.
A Java fordt minden esetben hibt jelez, ha gy szleli, hogy egy metdus valamilyen ellenrztt kivtelt vlthat ki, de az nem tartalmazza az
adott kivtelt elkap programblokkot, illetve a kivtelobjektum tpust
sem specifiklja. Ilyen esetek pldul a fjl- s hlzatkezelssel, specilis
sztringkonverzival stb. foglalkoz programrszek.
Vissza
123
Programozs III.
Kivtelkezels
Vissza
124
Kivteles esemny a kvetkez futs alatti esetekben keletkezhet:

A program futsa sorn valamilyen rendellenessg trtnt (tmb tlindexelse, oszts nullval, nemltez fjlra hivatkozs, stb).
A program egy throw utastsa vltotta ki a kivtelt. Ez megtrtnhet
a Java osztlyknyvtrakban, vagy a programoz ltal ltrehozott kdban is.
Egy aszinkron kivtel rkezett. Ez a tbbszl programokban fordul
el, amikor az egyik szl valamirt lell.
A leggyakrabban az elsknt emltett ok miatt keletkeznek kivtelek.
Ha egy kivteles esemny keletkezik a kd vgrehajtsa sorn, a programkdtl a virtulis gp tveszi a vezrlst. Ezutn egy olyan helyet keres
a programkdban, ahol a kivltott kivtel lekezelse megtrtnhet. A kivtel lekezelse egy specilisan arra definilt kdblokkban trtnik. A kivtelkezel blokkok egymsba gyazhatak, gy egyszerre tbb alkalmas ilyen
kdrszlet is ltezhet, ekkor a virtulis gp az egymsba gyazott blokkokbl kifel haladva az elsknt megtallt, hibt lekezel blokkot hajtja
vgre.
A kivtelkezel blokkjnak lefutsa utn a program a blokk utni utastssal folytatja futst.
7.1. Kivtelosztly definilsa
A kivtelek kezelsre szolgl Exception osztlynak szmos alosztlya
van, s ezek egytt egy sszetett osztlyhierarchit alkotnak.
A leggyakrabban elfordul kivtelek osztlya az Exception, vagy ennek
RunTimeException leszrmazottja, illetve ennek tovbbi leszrmazottjai.
A java.lang csomagban a kivteleknek kszen adott osztlyait talljuk. A sajt kivtelosztlyt a Throwable, az Exception vagy a
RuntimeException osztlyok kiterjesztseknt definilhatjuk. A sajt
kivtelosztlyok tbbszint hierarchit is alkothatnak.
Vissza
124
Programozs III.
Kivtelkezels
Vissza
125
21. bra : A kivtelosztlyok szerkezete (rszlet)

Az Exception osztly kzvetlen kiterjesztsei ellenrztt kivtelnek szmtanak, mg a RuntimeException kiterjesztsei nem ellenrzttnek. Egy
adott tpus kivtelt kivlt osztly programozjnak knyelmes, ha a kivtelt nem ellenrztt tpusnak definilja, azonban az indokolatlanul
ellenrizetlennek nyilvntott kivtelt kivlt osztlyt utbb felhasznl
msik programoznak, vagy az alkalmazs felhasznljnak annl tbb
kellemetlensge szrmazhat. Ezrt csak olyan kivteleket clszer nem
ellenrzttnek venni, amelyek elvileg brhol elfordulhatnak.
A kivtel osztlya fontos szerepet jtszik annak meghatrozsban,
hogy futsi idben melyik kivtelfeldolgoz blokk fogja elkapni (catch)
az aktulisan elllt kivtelt. Egy kivtelfeldolgoz blokk olyan kivtelobjektumot tud elkapni, amelynek osztlya a feldolgoz blokk paramternek
osztlyval azonos vagy a paramter osztlynak leszrmazottja. A kivtel
osztlynak defincijban a kivtelt ler attribtumokat (a hiba fellps-
Vissza
125
Programozs III.
Kivtelkezels
Vissza
126
nek krlmnyeit), az ezeknek rtket ad konstruktort s az olvas metdusokat lehet megadni, illetve felldefinilni.
class MyException extends Exception {
return Hiba trtnt!;
}
}
class MyException2 extends Exception {
public MyException2(String s) {
super(s);
System.err.println(MyException2 hiba lpett fel!);
}
}
7.2. A kivtel keletkezse, kivltsa

Legegyszerbb esetben egy feltteles utastssal vizsglunk egy helyzetet,
s ha a kivteles llapot elll, akkor a throw utastssal egy kivtelt vlthatunk ki (dobhatunk). Ekkor a vezrls az objektumot tartalmaz osztlyban megadott kivtelkezelsi utastsokat hajtja vgre.
int a, b, c;
//a vltozk futelzleg rtket kaptak

if (b==0){ throw new MyException();}
else c = a/b;
Az elre megadott, vagy a sajt osztllyal definilt kivtelt az egyes metdusokhoz is hozzrendelhetjk. Ehhez a throws kulcsszval a metdusfej
specifikcijba illesztjk a kivteles esemnyt lekezel osztlyt, vagy osztlyokat.
A RuntimeException osztlyba s ennek alosztlyaiba tartoz kivteleket a java krnyezet automatikusan a metdusokhoz rendeli. gy az
ezekbe az osztlyokba tartoz s gyakran elfordul hibkat nem kell a
metdusoknl megjelentennk, a virtulis gp a RuntimeException jelleg kivteleket szksg esetn automatikusan dobja.
<tpus> metdusnv(<paramterek>) throws KivtelOsztly { }
public void metodus1() throws MyException {
if (felttel) throw new MyException(Metodus1 hiba!);
Vissza
126
Programozs III.
Kivtelkezels
Vissza
127
7.3. A kivtel feldolgozsa

Eddig mg csak kivltottuk a hibt, de szeretnnk is kezdeni valamit ezekkel a kivtelekkel. A feldolgozshoz a Java krnyezet szabvnyos vezrlsi
szerkezetet definil.
Ha a throw utastssal elll, vagy a krnyezet ltal automatikusan
kivltott kivteleket el szeretnnk kapni, akkor ahhoz a levdend utastsokat, metdushvsokat egy try {} blokkba kell helyezni.
Az ilyen blokkban vgrehajtott utastsokat a virtulis gp megprblja
vgrehajtani. Ha nem sikerl, akkor a kzvetlenl a try blokk utn ll
catch szerkezet (vagy szerkezetek) segtsgvel megprblhatjuk elkapni a
kivtelkor keletkez objektumot.
A try-catch szerkezet legegyszerbb vza a kvetkez:
try {
// Kivtelt kivlt blokk.
}
catch(KivtelOsztly1 kivtelobjektum){
// A kivtelt elkap/feldolgoz blokk.
}
A catch blokkokbl tbbet is definilhatunk, ha a hibt tbbflekppen

szeretnnk kezelni. Utols blokknt egy finally blokkot is definilhatunk
try {
}
catch(KivtelOsztly1 kivtelobjektum){
// 1. tpus kivtel feldolgozsa.
}
catch(KivtelOsztly2 kivtelobjektum){){
// 2. tpus kivtel feldolgozsa.
}
finally {
// Zr blokk
}
A kivtelt elkap/feldogoz programrszt a megfelel catch blokkban

kell megrni. Egy catch blokk a paramtere tpusnak megfelel osztly
kivtelobjektumot tud elkapni, ami gy rtend, hogy a kivtelobjektum
tpusa azonos a paramter tpusval vagy leszrmazottjval.
Ha a try blokk ltal kivltott k1 kivtel osztlya (KivtelOsztly1)
kzvetlen vagy kzvetett leszrmazottja a k2 osztlynak
Vissza
127
Programozs III.
Kivtelkezels
Vissza
128
(KivtelOsztly2), s a kt kivtelt klnbzkppen kell feldolgozni,

akkor lnyeges a catch blokkok sorrendje. Ilyenkor a k2 kivtelt elkap
catch(KivtelOsztly2 ...) blokk nem elzheti meg a k1 elkapsra
sznt catch(KivtelOsztly1 ...) blokkot, mert akkor az a k1-et is
elkapn, azaz a k1 kivtel nem jutna el oda, ahol szndkunk szerint fel
kellene dolgozni.
Ha ugyanis valamelyik catch blokk megkapta a vezrlst, akkor azt mr
sem a try blokk nem kapja vissza, sem az adott try-catch-finally
kivtelkezel szerkezeten belli msik catch blokk sem kaphatja meg.
A kivtelt elkap catch blokk lefutsa utn finally blokk hinyban
a futs kilp a kivtelkezel szerkezetbl, klnben a szerkezetbl kilpst
mg megelzi a finally blokk lefutsa is.
Ha a try blokkban kivltott ellenrztt kivtelek valamely tpusra
nem rtunk catch blokkot, akkor az ilyen tpus kivtelt specifiklni a kell
a metdus fejrszben!
A finally blokkban a try blokk olyan befejez tevkenysgt kell
programozni, amelyet vgl mindenkppen vgre kell hajtani, akr megszaktotta a try blokk futst a valamelyik kivtel, akr nem.
try {
}
catch(ArrayIndexOutOfBoundsException e){
// Specilis kivtelt feldolgoz blokk.
}
catch(RuntimeException e){
// ltalnos kivtelt feldolgoz blokk.
}
catch(Exception e){
// Minden kivtelt feldolgoz blokk.
}
A kivtelosztlyok kztti leszrmazsi lnc a kvetkez: Exception

RuntimeException ArrayIndexOutOfBoundsException. A trycatch blokkokat a specilis kivteltl a minden kivtelt feldolgoz blokkig adtuk meg. Ha fordtva definilnnk a catch blokkokat, akkor sem az
ArrayIndexOutOfBoundsException, sem a RuntimeException kivteleket nem tudnnk kln-kln lekezelni, hiszen az sszes ilyen tpus
kivtelt a catch(Exception e) blokk kezeln le.
Vissza
128
Programozs III.
Kivtelkezels
Vissza
129
7.4. Krdsek
Mit jelent a kivtel, kivteles llapot fogalma?

Mi a klnbsg a hiba (error), s a kivtel (exception) kztt?
Mi vlthat ki kivteleket?
Mi trtnik a throw utasts utn?
Mi a try-catch-finally szerkezet koncepcija?
Tbb catch g definilsakor milyen szempontok szerint kell az egyes
feldolgoz gakat megtervezni?
7.5. Feladatok
A Sikidomok osztlyokhoz ksztsen sajt kivteleket ler osztlyokat,
amelyek az albbi hibk esetn vltanak ki kivtelt:
negatv, vagy zrus oldalhossz, vagy sugr megadsa,
megszerkeszthetetlen hromszgek megadsa,
olyan adatok megadsa, amelyeknl a szmtott rtkek mr tlcsordulnak.
Vissza
129
Programozs III.
A Java platform hasznos lehetsgei
Vissza
130
8. A Java platform hasznos

lehetsgei
8.1. Szveges adatok formzsa
A Java platform 5. kiadsban szmos olyan szveges formz utastst
definiltak, amelyek az elz verzikbl hinyoztak. A hagyomnyos Java
szintaktikval egyszer sztringmveletekkel, vagy sszefzssel lehet a
szveges kimenetet formzni. A fejleszti kzssg unszolsra bevezettk az ANSI C nyelvben jl ismert formzott szvegkezelst (printf),
amelyben egy mveletben tvztk a megjelentst s a formzst. A metdust a java.io.PrintWriter s java.io.PrintStream osztlyokban helyeztk el.
A metdus vltoz szm paramtert fogadhat. Az els paramter a
kiratni kvnt szvegadat, amelyben klnleges formz karaktereket helyezhetnk el. A formz karakterek (formtum specifiktorok) meghatrozzk, hogy a tovbbi paramterek milyen mdon jelenjenek meg szveges adatknt. A formz karakterek %-jellel kezddnek, s valamilyen
tpust jell karakterrel vgzdnek. ltalnos formban:
%<szlessg><.pontossg>tpuskarakter
A tpuskarakterek jellsre rszben tvettk a C nyelv szintaktikjt, rszben kiegsztettk a Java-specifikus formzsi lehetsgekkel. A tpuskaraktereket (nagy szmuk miatt) t f kategriba soroltk: ltalnos, karakter, numerikus (egsz vagy vals), dtum/id, illetve egyb tpusok.
A szveges formz karakterek lehetsges rtkeit a kvetkez tblzat
tartalmazza. (Tovbbi rszletekrt rdemes a java.util.Formatter
osztly specifikcijt ttanulmnyozni.)
Vissza
130
Programozs III.
Vissza
131
Formz
karakter
%b, %B
Tpus
Jelents
ltalnos
%h, %H
ltalnos
Ha a paramter null rtk, akkor az eredmny "false" lesz. Ha elemi boolean, vagy
Boolean objektum tpus, akkor az eretmny
"true", vagy "false" rtk lesz.
Ha a paramter null rtk, akkor az eredmny "null" lesz. Klnben az eredmny az
hexadecimlis rtk lesz, az
Integer.toHexString(arg.hashCode())
%s, %S
ltalnos
%c, %C
karakter
%d
egsz
%o
egsz
%x, %X
egsz
%e, %E
vals
%f
vals
%g, %G
vals
%t, %T
dtum/id
%%
%n
ltalnos
ltalnos
hvs eredmnyeknt.
Ha a paramter null rtk, akkor az eredmny "null" lesz. Ha a paramter megvalstja a Formatter interfszt, akkor annak
formatTo() metdusnak kimenete lesz,
klnben az eredmny a paramter
toString() rtke lesz.
Az eredmny Unicode formtum karakter
lesz.
Az eredmny tzes szmrendszer, egsz
formtum.
Az eredmny nyolcas szmrendszer, egsz
formtum.
Az eredmny hexadecimlis egsz formtum.
Az eredmny tzes szmrendszer, normlalak, vals formtum.
Az eredmny tzes szmrendszer, vals formtum.
Az eredmny tzes szmrendszer, rgztett
pontossg, normlalak s vals formtum.
A dtum/id formzsok jellsnl hasznlt
formzkarakter. Bvebben lsd: 0. fejezet.
A szzalkjel '%' ('\u0025')
Platformfgg sorvgjel. (CR, CR-LF)
5. tblzat: Szvegformzs
Vissza
131
Programozs III.
Vissza
132
Nzznk egy konkrt pldt:

System.out.printf(%s felhasznl %d prblkozs utn
bejelentkezett. Utols ltogats ideje: %tc %n,
felhNev, belepesekSzama, utolsoLatogatasDatuma);
Itt %s a jl ismert szveges helyettestst, %d egy egsz rtk helyettestst jelli, a %tc egy Date, Calendar, vagy milliszekundumokban megadott idadatot helyettest a loklis dtumformtummal, s legvgl a %n
egy platformfgg sorvgjelet jelent meg.
A PrintWriter s a String osztlyok ezeken fell rendelkeznek egy
format() nev osztlymetdussal. Mg a printf() egy megadott kimenetre kldi a formzott karakterlncot, addig a format() a megformzott
sztringet visszaadja. gy a fenti szveg inicializlhat j szveges vltozknt az albbi mdon:
String uzenet = String.format(%s felhasznl %d prblkozs
utn bejelentkezett. Utols ltogats ideje: %tc %n,
felhNev, belepesekSzama, utolsoLatogatasDatuma);
8.2. Naplfjlok hasznlata (logging)

Az egyszer konzol alkalmazsoknl, amikor a program csak a standard
kimenetre dolgozik, egyszer a figyelmeztetsek s a hibk jelzse. A fejleszts, majd a mkds szakaszban a System.out.print, vagy a
System.err.print hvsokkal a programok knnyen jelezhetik llapotaikat, a felmerl hibkat a fejleszt, vagy a felhasznl fel.
Ha azonban ha egy kliens-szerver alkalmazst, vagy egy sszetett projektet runk, akkor ez mr nem hasznlhat ki ilyen knnyen. A szerverprogramok jellemzen egy tvoli gpen futnak, amelyhez esetlen nincs is
karakteres terminl kapcsolva, gy pldul a karakteres konzolzeneteknek
nem igazn hasznlhtak. Ezekben az esetekben egy ms megoldst kell
vlasztanunk.
A Java 1.4-es kiadsa [11] ta lehetsgnk van a java.util.logging
csomag hasznlatra, amely a Java programok szabvnyos naplgenerlst
teszi lehetv. A naplkpzs ltalnosan a kvetkez elven mkdik: A
fejleszt egy Logger objektumot hoz ltre, amelyet sszekapcsol a figyelni
kvnt osztllyal, vagy csomaggal. Ezutn ez az osztly kpes az albbiakban trgyalt beptett, htszint zenetkezel mechanizmust hvni, abban
figyelmeztet, vagy informcis bejegyzseket elhelyezni az alkalmazs
bels llapotairl. Ezek az zenetek szmos szabvnyos formban megje-
Vissza
132
Programozs III.
Vissza
133
lenthetk: a memria egy elklntett rszn, a konzolon, egyszer szveges, vagy XML formzott fjlban, hlzati socketen keresztl, vagy ezek
valamely kombincijaknt.
A naplzsi mechanizmus segt a programok fejlesztsi, teleptsi s felhasznli szakaszban a rszletes hibadetektlsban, s a nyomkvetsben.
A java.util.logging csomag fbb osztlyai:
Logger: A naplkezels fosztlya. Az alkalmazsok a bejegyzseket
ezen osztly pldnyain keresztl kezdemnyezik. Szmos metdussal
rendelkezik, melyek a megfelel szinteken a naplba az adott zeneteket bejegyzik.
LogRecord: A LogRecord objektumok maguk az egyes logbejegyzsek vivobjektumai, a naplz mechanizmus ezeket kldi a Handler
fel.
Handler: Feladata a logbejegyzsek valamilyen kimenetre val elkldse (memria, fjl, socket stb.). Szmos leszrmazottja ismert.
(MemoryHandler, ConsoleHandler, FileHandler, SocketHandler,
treamHandler.)
Level: Az ltalnos naplbejegyzsekhez hasznlt jelzsszintek. A
programban bellthat, hogy a Logger s a Handler milyen szint s
a szint feletti logrekordokat kezeljen.
Formatter: A logrekord objektumok a kimenetre klds eltt a
Formatter osztlyok segtsgvel formzhatk, talakthatk. Jelenleg
kt implementcija adott, a SimpleFormatter s az XMLFormatter.
LogManager: A virtulis gp globlis objektuma. Felels a Logger
objektumok kezelsrt. gy egy nagyobb program osztlyai (akr ms
csomagbl is) ugyanazokat a loggereket hasznlhatjk.
A naplkezels a kvetkez modell szerint rtelmezhet:
Az alkalmazs indulsakor a LogManager inicializlja a Logger objektumok nvtert. Amennyiben egy konfigurcis fjlban van megadott
logmenedzser bejegyzs, akkor az azokban megadott rtkekkel inicializlja.
A programbl csak a Logger objektumhoz rkezhetnek zenetek.
Minden egyes Logger objektum rendelkezik egy nvvel, s egy naplzsi
kszbbel. A naplzsi kszb s afeletti szint zenetekbl a Logger
objektum egy LogRecord objektumot llt el s elkldi a megadott
Handlernek. A Handler ezt a Logrecord-ot a megadott Formatter
Vissza
133
Programozs III.
Vissza
134
segtsgvel megformzza, majd elkldi az osztlynak megfelel kimeneti

csatornra. (A Handler rendelkezhet a Logger-tl klnbz naplzsi
kszbbel, ez a setLevel() metdussal mdosthat, amelyet a Filter
osztlyban definil a Java krnyezet.)
LogRecord
Logger
i/n
LogRecord
Filter
kimenet
Handler
Loglevel
1,2,3,4,5,6,7
i/n
Filter
String
LogRecord
Formatter
Log mechanizmus
22. bra: A Java naplzsi mechanizmusa

A naplzsi szintekbl a Java API hetet rgzt elre. Ezeket a Level osztly definilja konstansknt: SEVERE a legmagasabb szint a rendszerszint hibk jelzsre,
WARNING a figyelmeztet zenetek szintje,
INFO,
CONFIG ,
FINE,
FINER,
FINEST a legalacsonyabb priorits szint, nyomkvetsi zene-
tekre.
Azokban a forrsokban, ahol a loggolst hasznlni szeretnnk, termszetesen importlnunk kell a java.util.logging csomagot. Ezutn egy
Logger s egy Handler objektumot kell ltrehoznunk. A programban a
logger s handler objektumot ssze kell kapcsolnunk, illetve bellthatjuk a
naplzs szintjt, s a handlerhez hozzrendelhetnk egy szrt is. Nagy
elnye ennek a mechanizmusnak, hogy a Logger objektumhoz tbb
handlert is rendelhetnk, gy a naplzs tbb gon, tbb mdszerrel is
folyhat egyidben.
Vissza
134
Programozs III.
Vissza
135
Az albbi mintapldban egy fjl-alap naplzst lthatunk mkds kzben.

import java.util.logging.*;
public class LogTeszt{
// Logger objektum inicializlsa
private Logger naplo = Logger.getLogger("sajatnaplo");
//a naplo bejegyzseket megjelent handler objektum
private Handler kezelo;
public void init() throws Exception{
//A naplo bejegyzseket egy fjlba szeretnnk kirni
kezelo = new FileHandler("valami.log");
// a logger rzkenysgnek belltsa
// (SEVERE, WARNING, INFO, CONFIG, FINE, FINER, FINEST),
naplo.setLevel(Level.FINEST);
// amely szveges formban jelenti meg a bejegyzseket
kezelo.setFormatter(new SimpleFormatter());
// s vgl a loggert sszekapcsoljuk a handlerrel
naplo.addHandler(kezelo);
// logbejegyzsek generlsa
naplo.info("Elindult a loggols!");
}
public void muvelet(int a, int b) {
naplo.fine("Algoritmus indul a="+a+", b="+b );
if (a>b){
naplo.warning("Az a nagyobb, mint b!");
}else if (a==b){
naplo.warning("Az a egyenl b-vel!");
} else {
naplo.warning("A b nagyobb, vagy egyenl mint a!");
}
naplo.fine("Itt vge a hasonlt algoritmusnak!");
}
Vissza
135
Programozs III.
Vissza
136
public int kivetel(int a, int b )throws

ArithmeticException{
// Belpsi zenet FINEST szinten
naplo.entering("LogTeszt","kivetel");
// kivtelkezelshez hasznlt loghvs FINEST szinten!
if (b==0) naplo.throwing("LogTeszt", "kivetel",
new ArithmeticException());
// Kilpsi zenet FINEST szinten
naplo.exiting("LogTeszt", "kivetel");
return a/b;
}
public static void main(String[] args) throws Exception{
LogTeszt pelda = new LogTeszt();
pelda.init();
pelda.muvelet(12, 13);
try {
pelda.kivetel(13, 0);
} catch (Exception e){
e.printStackTrace();
}
}
}
8.3. Dtum s idkezels

A dtum s idadatok brzolshoz a Java keretrendszer a kezdetektl
definilt tpusokat. Az idadatokat alapveten long tpus egszknt kpzelhetjk el, melyek a UNIX konvenci szerint az 1970 ta eltelt idt
szimbolizljk milliszekundumban. Mra az alaptpusokat kiegsztettk,
gy a legteljesebb ignyeket is kielgtik. A tpus alapjt a java.util.Date
osztly jelenti, melyben konstans idadatokat trolhatunk. A java.util.Calendar osztly s leszrmazottai segtsgvel pedig a dtum
s idadatokon vgezhetnk el klnbz konverzis mveleteket, szmtsokat.
Az idadatok kezelse egyrszt a csillagszati megfigyelseken, msrszt
a nagyon pontos atomrkon alapul. A csillagszati alap idszmtst Eurpban a GMT (Greenwich Mean Time) rendszer adja, melyben egy nap
24 60 60 = 86400 s. Azonban megfigyeltk, hogy a Fld forgsa nem
egyenletes, gy a GMT tudomnyos szempontokbl nem a legpontosabb.
Az atomrk korra sikerlt pontostani ezt az idszmtsi alapot, gy az
UTC (Universal Time Converter) szmtsban egy vben ktszer (jn. 30.
Vissza
136
Programozs III.
Vissza
137
s dec. 31.) a nap egy-egy extra msodperccel hosszabb. A Java virtulis

gpek alaprtelmezsknt ezt az UTC formtumot hasznljk.
8.3.1. A dtumkezel osztlyok
Date
Az idadatokat az 1970.00.00 00:00:00:000 idponttl szmtva milliszekundumokban trolja. Csak konstans idadatok kezelsre szolgl. Szmos metdusa mr elavult, mra mr csak a toString(), az equals(), a
before(), az after() hasznlhatak. A paramterek nlkli Date()
konstruktorhvs az aktulis gpidvel inicializlt dtumadatot tartalmaz
objektumot szolgltatja.
Calendar
A Date osztly kiegsztseknt hoztk ltre, amely az idadat trolsn
kvl egyes helyfgg szolgltatsokat is kpes kezelni (pl. idznk). Az
osztly pldnyaibl lekrdezhet, bellthat a kvnt dtumrtk, s klnbz konverzik vgezhetk el rajtuk.
A szmos elre definilt konstans rtk segtsgvel egy konkrt naptradat egyes sszetevi lekrdezhetk. Legfontosabb metdusok a
get(), a set() s az add(). Az add metdussal lehet pldul az egyes
dtumrtkhez valamilyen rtket hozzadni, melyet rtkhelyesen, a szkveket figyelembe vve vgez el. Pl: 2006.12.11 +3 hnap = 2007.3.11
lesz.
TimeZone
A TimeZone osztly a hordozhat programok, ms dtum s idformtumokra val inicializlsra s konvertlsra hasznlhat. A TimeZone
absztrakt
osztly,
nem
pldnyosthat.
Hasznlathoz
a
TimeZone.getDefault(zna) hvs szksges, ahol a zna egy szveges adatknt megadott idzna rtk. Az inicializlshoz szmos elre
rgztett rtk tartozik Europe/Budapest, America/Los_Angeles
formban. Azonban a GMT+01, vagy a GMT+0010 formtum is
hasznlhat, melyekben a greenwichi idznt 1 rval, illetve 10 perccel
toltuk el.
Az eurpai idszmtsi rendszerhez specilisan hasznlhat mg a
SimpleTimeZone osztly is, amely a Gergely-naptrakhoz olyan knnyen
hasznl funkcikat nyjt, mint pldul a tli/nyri idszmts pontos
kezelse.
Vissza
137
Programozs III.
Vissza
138
Dtumadatok formzott megjelentse

A Date s Calandar objektumok rendelkeznek mr elre definilt
toString() metdusokkal, gy a dtumadatok szveges reprezentcii
adottak. Azonban a megjelentshez UTC formtumot hasznlnak, amely
sokszor tlzottan rszletes, s nehezen olvashat: Fri Sep 08
13:31:05 CEST 2006. A szveges adatok formzsnl lttuk, hogy a
printf() s a format() metdusok alkalmasak dtum/id alak formzsra is a %t... formz karakter segtsgvel. Az albbi tblzatban ezeket a formtum specifiktorokat tekintjk t.
Formz
karakter
(idadatok)
%tH
%tI
%tk
%tl
%tM
%tS
%tL
%tN
%tZ
%ts
%tQ
Jelents
raadat 24 rs formtumban, vezet nullkkal feltltve,
00 - 23.
raadat 12 rs formtumban, vezet nullkkal feltltve,
01 - 12.
24 rs raadat, vezet nullk nlkl, 0 - 23.
12 rs raadat, vezet nullk nlkl, 1 - 12.
Percadat, vezet nullkkal feltltve, 00 - 59.
Msodpercadat, vezet nullkkalfeltltve, 00 - 60 (A "60"
olyan specilis rtk, amely az UTC korrekcis msodperceket jelzi).
Hrom karakteres milliszekundum adat, vezet nullkkal
feltltve, 000 - 999.
Kilenc karakteres nanoszekundum adat, vezet nullkkal
feltltve 000000000 - 999999999.
Az aktulis idzna szveges rtke.
Az UTC kezdrja ta eltelt msodpercek (1970. 01. 01
00:00:00 UTC ) rtkei Long.MIN_VALUE/1000 s
Long.MAX_VALUE/1000 kzttiek lehetnek.
Az UTC kezdrja ta eltelt id milliszekundumban.
rtkei Long.MIN_VALUE s Long.MAX_VALUE kzttiek
lehetnek.
6. tblzat: Dtum- s idformzs
Vissza
138
Programozs III.
Vissza
139
Formz
Jelents
karakter
(Dtumadatok)
Helyspecifikus, teljes hnapnv pl. "January", vagy janu%tB
r. (A formtum a helyspecifikus belltsokat kveti,
bvebben lsd Locale osztly)
Helyspecifikus, rvidtett hnapnv pl. "Jan", vagy jan..
%tb
Helyspecifikus, teljes alak napnv pl. "Sunday",
%tA
"Monday" , vagy vasrnap
Helyspecifikus, rvid formtum napnv. "Sun", "Mon" ,
%ta
vagy V, H
A ngyjegy vszmok els kt jegyt jell szmadat,
%tC
vezet nullkkal feltltve, 00 - 99
Ngyjegy vszmadat, vezet nullkkal feltltve, 0000
%tY
9999.
Ktjegy vszmadat, vezet nullkkal feltltve, 00 - 99.
%ty
Az v napjnak sorszma, vezet nullkkal feltltve, 001
%tj
366.
Ktjegy hnapadat, vezet nullkkal feltltve, 01 - 13.
%tm
Ktjegy napszm adat, vezet nullkkal feltltve, 01 - 31
%td
Ktjegy napszm adat, vezet nullk nlkl, 1 - 31.
%te
(Vegyes dtum/id formzsok)
24 rs idadat, megegyezik a "%tH:%tM"-vel
%tR
24 rs idadat, megegyezik a "%tH:%tM:%tS"-vel.
%tT
12 rs idadat, megegyezik a "%tI:%tM:%tS %Tp"-vel.
%tr
Dtumadat, amely megegyezik a"%tm/%td/%ty"-vel.
%tD
ISO 8601 formj dtumadat, megegyezik a "%tY-%tm%tF
%td"-vel.
UTC idformtum, megegyezik a "%ta %tb %td %tT
%tc
%tZ %tY"-vel.
7. tblzat: Dtum- s idformzs (folytats)
Vissza
139
Programozs III.
Vissza
140
Az albbi plda bemutatja a nyelv dtum- s idkezelsnek legfontosabb

elemeit:
import
import
import
import
import
java.util.Date;
java.util.Calendar;
java.util.GregorianCalendar;
java.util.TimeZone;
java.util.SimpleTimeZone;
class Datum {
// Melyik idznk megfelelek neknk, magyaroknak? (1 ra
Greenwich-tl)
String[] megfelelo=
TimeZone.getAvailableIDs(1*60*60*1000);
System.out.println("Greenwich-tl keletre 1 rnyira
lev idznk:");
for(int i=0;i<megfelelo.length;i++){
System.out.println("\t" + megfelelo[i]);
}
System.out.println("--------------------------");
//Vesszk azt az idznt, amit hivatalosan hasznlunk
//(Central European Time = GMT+1):
SimpleTimeZone cet = new SimpleTimeZone(1,"CET");
//Belltjuk a nyri idszmts kezdett prilis
//els vasrnapjra, hajnali 2 rra
cet.setStartRule(Calendar.APRIL, 1, Calendar.SUNDAY,
2*60*60*1000);
// ... s a vgt oktber utols vasrnapjra, 2 rra.
cet.setEndRule(Calendar.OCTOBER, -1, Calendar.SUNDAY,
2*60*60*1000);
//Ezzel az idznval ltrehozunk egy
//Gergely-fle idszmtst hasznl naptrat:
Calendar calendar = new GregorianCalendar(cet);
//Az aktulis idpillanatot lekrdezzk,
Date most = new Date();
// majd a naptrat belltjuk erre az idpontra.
calendar.setTime(most);
// ezutn jn a kirats a Calendar osztly konstansaival
System.out.println("Az aktulis id:");
System.out.print(calendar.get(Calendar.ERA)==0 ? "i.e. "
: "i.sz. ");
System.out.print(calendar.get(Calendar.YEAR) + ".");
System.out.print((calendar.get(Calendar.MONTH)+1) + ".");
System.out.print(calendar.get(Calendar.DATE) + " ");
Vissza
140
Programozs III.
Vissza
141
System.out.print(calendar.get(Calendar.AM_PM)==1?"du "
:"de ");
System.out.print((calendar.get(Calendar.HOUR)+1) + ":");
System.out.print(calendar.get(Calendar.MINUTE) + ":");
System.out.print(calendar.get(Calendar.SECOND) + " mp. ");
System.out.println(calendar.get(Calendar.MILLISECOND) +
" ezredmp.");
System.out.println("Ez a "+
calendar.get(Calendar.DAY_OF_YEAR)+
". nap ebben az vben.");
System.out.println("A hnap +
calendar.get(Calendar.WEEK_OF_MONTH) +
"., a teljes v " +calendar.get(Calendar.WEEK_OF_YEAR)+
". hetben jrunk. ");
// hrom hnap mlva milyen nap lesz?
System.out.println("Hrom hnap mlva ilyenkor: ");
calendar.add(Calendar.MONTH, 3);
System.out.println(calendar.get(Calendar.YEAR)+ "."
+(calendar.get(Calendar.MONTH)+1) + "."
+calendar.get(Calendar.DATE));
}
}
8.4. Idmrs nanoszekundumokban

Az alaprtelmezett legkisebb idmrtk, melyet a dtumosztlyok hasznlnak, a milliszekundum. Azonban korltozsokkal, a futsidej mveletek mrsre nanoszekundumos felbontst is hasznlhatunk. A java 5.
verzijtl a System osztly rendelkezik egy currentTimeMillis() s
egy nanoTime() metdussal. Ezek a metdusok egy-egy long tpus rtkkel szolglnak, melyek a relatv futsidt szimbolizljk. Algoritmusok
szmtsignynek mrsre hasznos segtsget nyjthatnak.
long start = System.nanoTime();
muvelet();
long end = System.nanoTime();
long elteltIdo = end-start;
8.5. Tmbmveletek
A 3.2.9. fejezetben megismerkedtnk a Java tmbkezelsi mdszereivel. A
sztringkezels sorn megismertk azokat a metdusokat, amelyek a szveges adatokat bjt-, vagy karaktertmbbe konvertlja, illetve ilyen tmbk-
Vissza
141
Programozs III.
Vissza
142
bl llt el sztringadatokat (3.2.10.). Sok esetben azonban a tmbkkel

ms mveleteket is szeretnnk elvgezni.
A sokszor hasznlt java.lang.System osztly rendelkezik egy statikus arraycopy() metdussal, amely azonos tpus tmbk kztti
adatmsolst tesz lehetv. Az adatmsols a tmb egszt, vagy egy tartomnyt rintheti. Ha nem azonos tpusokkal prblkozunk, akkor ezt a
fordt incompatible types hibazenettel jelzi.
Msoljuk t egy karakteres tmb egy rsztartomnyt egy msik tmbbe.
char [] szoveg = "Java Standard Edition 5.0".toCharArray();
char [] masolat = new char[100];
char [] masolat2 = new char[100];
// A szveg 5. karaktertl kezdden a msolatba,
a 0. karaktertl kezdve 16 karaktert msolunk.
System.arraycopy(szoveg, 5, masolat, 0, 16);
// A masolat tmb 9. karaktertl msolat2-be,
az 5. elemtl kezdve a 7 karaktert tmsolunk.
System.arraycopy(masolat, 9, masolat2, 5, 7);
//A tmbk tartalma:
for (int i=0; i<szoveg.length; i++)
System.out.print(szoveg[i]);
// Kimenet: Java Standard Edition 5.0
for (int i=0; i<masolat.length; i++)
System.out.print(masolat[i]);
// Kimenet: Standard EditionNULL,NULL...
for (int i=0; i<masolat2.length; i++)
System.out.print(masolat2[i]);
// Kimenet: NULL,NULL,NULL,NULL,Edition,NULL,NULL...
Megfigyelhet, hogy a msolat tmb azon rszei, ahova nem kerlt rtelmes karakter, a 0 ASCII kd karakterrel inicializlt.
A java.util csomag tartalmaz egy Arrays nev osztlyt. Ez az osztly
azokat a knnyen s egyszeren hasznlhat tmbmveleteket foglalja
magba, mint a tmbk inicializlsa megadott kezdrtkekkel, a binris
keress, a rendezs, s az rtkek szerinti sszehasonlts.
Vissza
142
Programozs III.
Vissza
143
A mveletek osztlymetdusokknt lettek definilva, gy hasznlatuk a

kvetkez alak: Arrays.muvelet(paramterek). Az Arrays osztly
hasznlathoz termszetesen a forrsprogram elejn importlni kell:
import java.util.Arrays;
A tmbmanipulcis mveletek alapja a tmb elemeinek sszehasonlthatsga. A Jva alaptpusait hasznl tmbk esetn (boolean, int,
double, char stb.) a rendszer gondoskodik a tpusnak megfelel, n.
alaprtelmezett sorrendrl, gy ezeknl ltalban nem tkznk akadlyokba. Ugyangy sztringek esetn is ltezik egy alaprtelmezett sorrend,
hiszen a String osztlyt az API eleve sszahasonlthatnak definilja.
Objektumok hasznlata esetn azonban mr a programoz felelssge
az objektumok sszehasonlthatsgnak biztostsa. Ehhez az Arrays
osztly megkveteli a Comparable, illetve a Compare interfsz implementlst, s annak compateTo(), vagy compare() metdusnak kifejtst.
(Bvebben lsd a 0. fejezetben.)
Az Arrays osztly leggyakrabban hasznlt mvelete a rendezs. A
sort() metdus segtsgvel rendezhetjk a tmb tpusa szerinti termszetes sorrendbe. A sort mveletet meghvhatjuk az egsz tmbre, illetve
a tmb egy intervallumra.
A msik gyakori mvelet egy elem kikeresse. Az Arrays osztlyban a
binris keress algoritmust implementltk a fejlesztk.
Nagyon fontos azonban tudni, hogy a binris keres algoritmus csak rendezett tmb esetn mkdik, rendezetlen tmb esetn meghatrozhatatlan
a vgeredmny!
A binris keress ugyangy, mint a rendezs felttelezi, hogy a tmb elemi
sszehasonlthatk. A fordt itt is megkveteli a megfelel interfszek
implementlst. A binarySearch() metdus kt paramtert fogad: magt a rendezett tmbt, s a keresett rtket. A keresett rtk tpusnak
meg kell egyezni a tmb elemeinek tpusval, gy sok esetben explicit tpuskonverzit kell hasznlnunk.
Rendezznk egy egsz szmokbl ll tmbt, majd keressk meg egyes
konkrt rtkek helyt (indext)!
Vissza
143
Programozs III.
Vissza
144
short [] egesztomb = new short[] {12, 3, -5, -1, 15, 0};

Arrays.sort(egesztomb);
// {-5, -1, 0, 3, 12, 15}
for (int i=0; i<egesztomb.length; i++)
System.out.print(egesztomb[i]+ " ");
int index = Arrays.binarySearch(egesztomb,(short)3);
System.out.println("\nA 3 pozcija: "+ index);
index = Arrays.binarySearch(egesztomb,(short)100);
// nem tallhat, negatv visszatrsi rtk
System.out.println("A 100 pozcija:" +index);
// 3.
A fenti pldban a sort metdust az egsz tmbre alkalmaztuk. Abban az

esetben, ha a tmbnek csak egy rszintervallumt rendezzk, lljon pldul a kvetkez forrskd-rszlet:
Arrays.sort(egesztomb, 2,4); //{12, 3, -5, -1, 15, 0}
A paramterknt megadott kt egsz szm a rendezend tmbtartomny

indexeit jelzi.
Referenciatmbk esetn a fenti mveletek ugyangy hasznlhatk.
Az albbi pldban bemutatjuk az Arrays.equals() metdus mkdst tmbk esetben. Az sszehasonlts sorn akkor lesz egyenl a
kt tmb, ha annak minden elemprja megegyezik. Ehhez szksges, hogy
az objektumok rendelkezzenek felldefinilt equals() metdussal. (Az
Arrays.equals() metdus az objektumok sajt equals() metdusait
fogja meghvni.)
Pldnkban a String objektumok rendelkeznek equals() metdussal, amely akkor tr vissza igaz rtkkel, ha a kt karakterlnc minden karaktere megegyezik.
// Referenciatmbk tmbmveletei
String [] szovegtomb = new String[] {"itt", "az", "id"};
//msolatkszts az Object.clone() metdussal
String [] masolata = (String [])szovegtomb.clone();
Arrays.sort(szovegtomb); //{"az", "id", "itt"}
for (int i=0; i<szovegtomb.length; i++)
System.out.print(szovegtomb[i]+" ");
// megvizsgljuk a kt tmbt
boolean egyezik = Arrays.equals(szovegtomb, masolata);
System.out.println("\nA kt tmb "+
(egyezik?"megegyezik!":"nem egyezik meg!"));
Az Arrays osztly hasznlhat tbbek kztt mg adatfeltltsre, s

kezdrtkadsra, amelyet a fill() metdus segtsgvel az lbbi mdon
adhatunk meg:
Vissza
144
Programozs III.
Vissza
145
byte[] data = new byte[100]; // res tmb, minden elem 0

kezdrtk
Arrays.fill(data, (byte)-1); // minden elem -1 rtk
Arrays.fill(data, 3, 7, (byte)-5); // tartomny feltltse:
//{-1, -1, -1, -5, -5, -5, -5, -5, -1, -1,.....}!
8.6. Krdsek
Melyek a hasonlsgok s a klnbsgek az ANSI C s a Java nyelv
szvegformz lehetsgei kztt?
Milyen clra hasznljuk a naplz fjlokat?
A naplzsnak milyen kimeneti csatorni lehetnek?
Mi a klnbsg a Logger s a Handler osztly kztt?
Mi jellemzi a Java dtum- s idkezelst?
Melyik osztly segtsgvel tudunk klnleges tmbmleteket vgezni,
s hogyan?
8.7. Feladatok
Az Alkalmazott osztlyt egsztse ki egy szletsi dtumot tartalmaz
adattaggal, s mdostsa az rintett metdusokat.
Ksztsen egy tetszleges feladathoz egy komplett naplz szolgltatst.
Vissza
145
Programozs III.
Fejlett adatszerkezetek
Vissza
146
9. Fejlett adatszerkezetek
A programtervezsi munkban gyakori feladat a rgztett objektumok
valamilyen szempont szerinti csoportostsa, rendezse, adott tulajdonsg
elem megkeresse, illetve a trolt elemek karbantartsa (j elemek felvtele, mdosts, trls stb.). Az elemek karbantartshoz s az elemek keresshez az elemeket valahogyan azonostanunk kell, vagyis meg kell tudnunk llaptani egy elemrl, hogy azt keressk-e (referencija, vagy valamely tulajdonsga alapjn). Tovbb a rendezshez ezeket az elemeket
ssze kell tudni hasonltani, vagyis meg kell llaptanunk, hogy melyik objektum szerepel majd a sorban elbb, illetve utbb.
A programozsi gyakorlatban szmos adattrolsi mdszer s rendezsi algoritmus ltezik, ezeket tbb-kevsb a Java krnyezet is tmogatja.
A klasszikus adatmodellek s a rajtuk rtelmezett eljrsmodellek az objektumorientlt rendszerekre is kiterjeszthetk. A magasabb fok adatszerkezetek amelyek majd az egyes objektumokat troljk kiegszthetek az
adatszerkezetet manipull mveletekkel. Zrt egysgbe rendezhetek,
vagyis megadhatak rjuk interfsz-, illetve osztly definci.
A magasabb fok adatszerkezeteket az albbi modell szerint rendszerezhetjk:
Asszociatv adatszerkezetek: az elemek kztti laza kapcsolatokat az
elemek azonos tulajdonsgai ltestik.
Tmb, dinamikus tmb,
Indextbla,
Halmaz.
Szekvencilis adatszerkezetek: az egyes elemek szigoran egymst
kvetve helyezkednek el. Mindig van egy kezdelem, s minden elemet
egy msik kvet. A kapcsolat 1:1 jelleg.
Verem (LIFO),
Sor (FIFO),
Ktirny s cirkulris listk.
Hierarchikus adatszerkezetek: az elemek egymssal alflrendeltsgi viszonyban vannak. A kapcsolatok 1:N alakak.
Fa (binris-, tbbg-, fesztfa, kupac)
sszetett listk
Vissza
146
Programozs III.
Vissza
147
Hls adatszerkezetek: brmelyik csompont brmelyik csomponttal kapcsolatban llhat. A kapcsolatok N:M alakak.
Irnytott grf
Hlzat
9.1. A gyjtemny keretrendszer
A bels osztlyok trgyalsakor mr lttunk egy pldt az egyirny lista
egy lehetsges megvalstsra (lsd: 5.4. fejezet). A Java osztlyknyvtrakban a java.util csomagban megtallhat a Gyjtemny keretrendszer(Collection Framework), amely a legfontosabb s gyakran hasznlt
adatszerkezetekre ksz modelleket ad. A Java osztlyknyvtrak 1.5-s
kiadsakor ezt a csomagot alaposan kibvtettk.
A legjellemzbb gyjtemnyfajtk a tmbkre, dinamikus tmbkre
s az objektumok referencikon keresztl trtn sszekapcsolsn alapulnak.
A gyjtemny keretrendszer felptsi elve a kvetkez:
Az interfszek hierarchija a megfelel absztrakt adattpusokat specifiklja. Az ket megvalst osztlyok pedig tartalmazzk a konkrt adat- s
mveletreprezentcikat. Az interfszek s a megvalst osztlyok sztvlasztsra azrt van szksg, hogy a magas szint objektumorientlt
modellezst (OOA, OOD) a tartalmazott adatoktl fggetlenl tegyk
lehetv.
Az elkszlt tpusok hosszas tervezsi s tesztelsi folyamat eredmnyei, gy hasznlatuk nvelheti a fejlesztend programok megbzhatsgt.
Az albbiakban megismerkednk a magasabb szint sszetett adatszerkezetek alapfogalmaival, majd ttekintjk a Java csomag egyes interfszeit,
osztlyait.
9.1.1. A kontner
Kontner objektumoknak nevezzk az 1:N adatszerkezeteket megvalst

sszetett osztlypldnyokat. Egy kontnerosztly az adatstruktra trolsn kvl a keressi, bejrsi s karbantartsi funkcikat is megvalstja.
(Els kzeltsben egy egyszer egydimenzis tmb is kontnernek
szmthatana, de tbb szempont szerint sem beszlhetnk kontner viselkedsrl, hiszen a tmb nem tekinthet osztlynak, s a karbantart mveleteket is csak az adatszerkezettl elvlasztva lehetne megadni.)
Vissza
147
Programozs III.
Vissza
148
A Java gyjtemny keretrendszerben a kontner osztlyok magas

szint modelljnek vzt s mkdsnek alapelemeit a Collection interfsz tartalmazza.
A kontner olyan objektum, amely objektumokat trol, s alkalmas klnbz karbantartsi, keressi s bejrsi funkcik megvalstsra.
Modellezsi s programfejlesztsi szempontbl a fejleszt feladata azt a
kontnerosztlyt kivlasztani, ami az adott feladat megoldsra a legalkalmasabb. Ha nincs a feladatra alkalmas kontner, akkor vagy egy mr meglv osztly leszrmaztatsval az osztlyt tovbbfejlesztjk, vagy nagyon
ritkn egy teljesen jat runk.
A Java osztlyknyvtrai ltalnosak s brmilyen osztlybl szrmaz
objektumot tartalmazhatnak. A kontnerbe felvett objektumok ezen ltalnossg miatt Object osztlyak lesznek. gy egy kontner elemeinek
metdusait csak tpusknyszertssel rhetjk majd el:
((Osztlytpus)elemelrs).metdus();
A tpusknyszerts sorn a zrjelezs azrt szksges mert a . opertor magasabb priorits, mint a tpusknyszerts.
Megjegyzs: A generikus tpusok alkalmazsval elhagyhatk lesznek az
explicit tpuskonverzik, gy a sokszor olvashatatlann vl kd kiegyszersthet (lsd: 9.4. fejezet).
9.2. A gyjtemny keretrendszer interfszei
Elszr az absztrakt modellel, vagyis az interfszekkel kell megismerkednnk. Itt adhat meg a trolt adatoktl fggetlen mkds, s itt rhat el
a szmtalan leszrmazott osztly szmra az azonos zenetklds. A
polimorfizmus segtsgvel az egyes leszrmazott osztlyokban megadhatak lesznek a specilis keres, rendez s bejr algoritmusok. A keretrendszer az albbi interfszeket definilja:
Vissza
148
Programozs III.
Vissza
149
Collection
List
Queue
Set
SortedSet
Map
SortedMap
A kontner osztlyokat csoportosthatjuk abbl a szempontbl, hogy az

az adatokat milyen adatstruktra szerint trolja:
Kollekci-jelleg: A kollekci jelleg kontner egyszer soros adattrolst valst meg. Ilyen osztlyok a Vector, HashSet, TreeSet,
ArrayList, LinkedList stb.
Lekpezs-jelleg: Egy lekpezs-jelleg kontnerben a nyilvntarts
kulcsobjektumok szerint trtnik. A kulcshoz informcihordoz objektumok rendelhetk. A kulcsok alapjn a keressi s karbantartsi
munkk hatkonyabbak. Ide tartoznak a HashMap, HashTable,
TreeMap stb.
Tekintsk t, hogy a Java osztlyknyvtrakban definilt interfszek milyen lehetsgeket knlnak a kontner jelleg adattrolshoz:
A Collection interfsz a kollekci jelleg osztlyok se, gyjtmodellje.
A belle szrmaz interfszek, majd osztlyok az adattrolst ms-ms
mdon valstjk meg. Hol engedlyezett az elemek tbbszrs felvtele, hol nem. Valahol a trols rendezett, mg mshol rendezetlen.
A List interfsz a dinamikus listkat tartalmaz osztlyok kzs interfsze. Ezekben a kontnerekben az elemek sorrendje szigoran soros,
az elemek indexelhetek, az adatok nem rendezettek.
A Queue interfsz az adatsorok, elssorban a FIFO jelleg trolk
hasznlathoz nyjt modellt. Egyes implementl osztlyok a sorokat
prioritsos sorknt kezelik, vagyis rtelmezik a sorok rendezst.
A Set interfsz a halmaz-jelleg adattrols magas szint megvalstsa. Egy halmazba csak egyedi adatok tehetk, kt azonos objektum
nem trolhat.
A SortedSet interfsz a rendezett halmaz-jelleg kontnerosztlyok
mkdst rja le. Mint a Set interfsz leszrmazottja, az t implementl osztlyokban is az adattrols egyedi.
Vissza
149
Programozs III.
Vissza
150
Az kollekciktl fggetlen lekpezs jelleg interfszek kezelse. A

Map (lekpezs) interfszt implementl osztlyok kulcs-rtk prok
alapjn trolja a bejegyzseket. A kulcsokat valamilyen kollekciban troljk, segtsgkkel rhetek el a tartalmazott objektumok. (Mind a
kulcsok, mind az rtkek lehetnek elemi, vagy objektum tpusak.)
A SortedMap a Map interfsz leszrmazottja, az t implementl
osztlyokban lehetsgnk van a kulcsok rendezsre.
9.3. A gyjtemny keretrendszer osztlyai
A gyjtemny keretrendszer kontner osztlyai az elz pontban trgyalt
interfszek megvalstsval egy-egy konkrt adattrolsi osztlyt hatroznak meg. Ezeknek az osztlyoknak pldnyai a programokban egy-egy
osztly adattagjaiknt, vagy akr loklis vltozknt is felhasznlhatk
ugyangy, mint ms objektumpldnyok.
9.3.1. Halmazok
A halmazok valamilyen kzs jellemzvel br adatok laza kapcsolata.

Az elemek egynileg elrhetek, de nem ismerik egymst.
HashSet
A Set interfszt valstja meg, gy elemei egyediek, s rendezetlenek. A
kontner osztlyban az albbi halmazmveletek rtelmezettek: elem hozzadsa a halmazhoz (add), elem tartalmazs vizsglata (contains), elemek trlse (clear). Az elemeket az n. hastsi technika segtsgvel
(hashing) tarthatjuk karban. A hasts lnyege az, hogy az elemeket valamilyen szempont szerint csoportostjuk, s ezekhez a csoportokhoz egy-egy
hast kdot rendelnk (pl: szmok tzes maradka, nevek kezdbetje
stb.). Az egyes elemeket ezutn az gy elll csoportokhoz egyrtelmen
hozzrendeljk. A hast kdokkal egy rendkvl gyors indexelsi eljrst
kapunk, gy az elemek visszakeresse s manipullsa nagyon hatkony
lehet, igaz az adattrols sorrendje kaotikus, elre nem meghatrozhat.
(A hashCode metdus felldefinilsval lehetsgnk van sajt hast
fggvnyeket is definilni.)
Egy programrszletben mutassuk be a halmaz mkdst. Egy szvegbl
keressk ki a benne szerepl betket.
Vissza
150
Programozs III.
Vissza
151
String szoveg = Micimack;

Set betuk = new HashSet();
for (int i=0; i<szoveg.length(); i++){
betuk.add(new Character(szoveg.charAt(i)));
}
System.out.print(A +szoveg+ -ben tallhat betk:);
System.out.println(betuk);
Lehetsges kimenete: [i, k, M, a, c, ]
A pldban a betuk egy HashSet tpus kontner objektum. A szveg

bejrsakor a karakterek csomagol osztlynak segtsgvel (Character)
egy-egy j objektumot hoztunk ltre, amely az egyes karaktereket referencival elrt objektumokknt kezeli. Ezeket a referencikat a halmazhoz
adjuk. A Character osztly equals() metdusval a httrben, a behelyezend karaktereket sszehasonltja a mr troltakkal, s ha ilyen elem
mg nem szerepelt, akkor azt a halmazba felveszi.
Kiratskor az osztly toString metdust rjk el automatikus konverzival.
Figyeljk meg, hogy a betuk deklarlsakor az interfsznek megfelel
tpust (Set) rendeltnk az azonosthoz. Ez a megads nem hibs, hiszen
a halmazzal az interfszben megadott mveletekkel kommuniklunk. Segtsgkkel lehet a redszertervek absztrakt tervezs modelljeit lpsenknt konkrt trol osztlyokk alaktani. (Ez a mdszer a kvetkez fejezetekben tbbszr is elfordul.)
TreeSet
Ez is egy halmazt valst meg, de mivel a SortedSet interfszt implementlja, ezrt csak olyan objektumokat tartalmazhat, amelyek egymssal szszehasonlthatk. Az sszehasonltshoz az osztlyoknak a Comparable
interfszt implementlniuk kell. Azelz pldban a TreeSet osztlyt is
hasznlhatjuk a betk vizsglatra, hiszen a Character csomagol osztlyban definiltk az sszehasonlts mvelett (compareTo). A pldban
a betuk deklarcijt adjuk meg az albbi alakban:
Set betuk = new TreeSet();
Vissza
151
Programozs III.
Vissza
152
Ekkor a program az objektumokat mr rendezetten trolja. Az osztly

nevbl kvetkeztethetnk, hogy a halmaz trolsi mdja egy fval trtnik. Ezt a bels, kiegyenslyozott binris fval trtn trolst a kontner
osztly elrejti ellnk.
Ha sajt objektumokat szeretnnk TreeSet-ben trolni, akkor a tpust
definil osztlynak implementlnia kell a Comparable interfszt, ebbl
kvetkezen ki kell fejteni a compareTo metdust, ahol definilhatjuk az
osztlyba tartoz pldnyok sszehasonlt mvelett valamely jellemz
alapjn.
Troljunk egy rendezett halmazban tglalapokat.
A rendezshez a mr rgebben definilt Teglalap osztlyt fel kell kszteni a kontnerben val trolsra az albbi mdon:
public class Teglalap implements Comparable {
private double a, b;
public Teglalap (double a, double b) {
this.a = a;
this.b = b;
}
public double kerulet() {return 2*(a+b); }
public double terulet() {return a*b; }
public String toString(){
return ("Tglalap ["+a+","+b+"]");
}
// A Comparable interfszben deklarlt metdus:
public int compareTo(Object obj){
return
(int) ( this.terulet() ((Teglalap)obj).terulet() );
}
}
Az albbi programrszlet segtsgvel adhatunk meg rendezett halmazt:

Teglalap t1 =new Teglalap(5,6);
Teglalap t2 =new Teglalap(4,4);
Set alakzat= new TreeSet();

alakzat.add(t1);
alakzat.add(new Teglalap(12,4));
alakzat.add(t2);
alakzat.add(t1); //mr egyszer szerepel, gy kimarad!
Vissza
152
Programozs III.
Vissza
153
System.out.println(alakzat);
Kimenet:
[Tglalap [4.0,4.0], Tglalap [5.0,6.0], Tglalap
[12.0,4.0]]
A Comparable interfsz megvalstst a fordtnak az implements

kulcsszval jelezzk. Ekkor meg kell adni az int compareTo(Object
o) metdus defincijt, amely az aktulis pldny s a paramterben rkez referencia sszehasonltst teszi lehetv. Visszatrsi rtke egy
egsz szm. A definciban a tglalapok nagysgt terletkkel mrjk.
Termszetesen megadhat ms szably is.
Ha a compareTo metdust nem definiljuk, akkor does not override
abstract method fordtsi hibazenetet kapunk, ha pedig a Comparable
interfszt felejtjk el bejelenteni, akkor a futs sorn a futtat krnyezet
nem tudja garantlni, hogy ugyanazt a comapareTo metdust ltja, amit az
interfsz megkvetel, s ClassCastException kivtelt vlt ki az sszehasonlts mvelete.
LinkedHashSet
A HashSet osztly bvtse, ahol az adattrols ktirny lncolt listban
trtnik. Ez egy olyan halmazt eredmnyez, amely az elemeket beviteli
sorrendben tartalmazza. (A HashSet elre megjsolhatatlan sorrendben
adja vissza az adatokat.) Ez az osztly j kompromisszum abban az esetben, ha az elemek sorrendje szmt, s gyorsabb adatmanipulcit szeretnnk, mint amit a TreeSet nyjt.
BitSet
Segtsgvel egy dinamikus bitsorozatot tartalmaz objektumot kezelhetnk. A BitSet osztly objektumain knnyen vgezhetnk logikai mveleteket (S, VAGY, kizr VAGY), vehetjk kt halmaz metszett, kiszmthatjuk kardinalitst (a benne szerepl true rtkek szma). A
megvalstsban egy olyan logikai elemekbl ll halmazrl van sz, amely
indexelhet, elemei elrhetek. Ez az osztly nll, megvalstsa az elzektl fggetlen (nem implementlja a Set interfszt)!
brzoljuk bitsorozatokkal a szmok kettvel, hrommal s hattal val
oszthatsgt.
Vissza
153
Programozs III.
Vissza
154
BitSet paros = new BitSet(10);

BitSet harommalOszthato = new BitSet(); //res halmaz
BitSet hattalOszthato = new BitSet();
for (int i=0; i< 20; i+=2){
paros.set(i);
hattalOszthato.set(i);
}
for (int i=0; i< 20; i+=3){
harommalOszthato.set(i);
}
// BitSet mvelet: S
hattalOszthato.and(harommalOszthato);
System.out.println("Pros szmok: "+paros);
System.out.println("Hrommal oszthat szmok: "
+harommalOszthato);
System.out.println("Hattal oszthat szmok: "
+hattalOszthato);
//Kimenet:
//Pros szmok: {0, 2, 4, 6, 8, 10, 12, 14, 16, 18}
//Hrommal oszthat szmok: {0, 3, 6, 9, 12, 15, 18}
//Hattal oszthat szmok: {0, 6, 12, 18}
EnumSet
Mint azt a 3.2.12. fejezetben lthattuk, a Java 1.5-s verzijtl lehetsgnk van felsorolt tpus adatok hasznlatra (enum) [12]. A kollekci
keretrendszerben helyet kap tpus a java.util.EnumSet. Ebben az
adatszerkezetben a felsorolt tpus adatok halmazt kszthetjk el. A mkds elve eltr a tbbi halmaztl, mert itt az j tpust csak kzvetlenl a
specilis halmazmveletek segtsgvel hozhatjuk ltre, az albbi mdokon:
public enum Napok {HE, KE, SZE, CSU, PE, SZO, VAS};
EnumSet foglaltNapok = EnumSet.of(Napok.HE, Napok.SZE,

Napok.PE);
EnumSet hetNapjai = EnumSet.allOf(Napok.class);
EnumSet ures = EnumSet.noneOf(Napok.class);
EnumSet szabadNapok = EnumSet.complementOf(foglaltNapok);
EnumSet munkaNapok = EnumSet.range(Napok.HE, Napok.PE);
Vissza
154
Programozs III.
System.out.println(
System.out.println(
SZO, VAS]
System.out.println(
System.out.println(
System.out.println(
Vissza
155
foglaltNapok );
// [HE, SZE, PE]
hetNapjai );
// [HE, KE, SZE, CSU, PE,
ures ); // []
szabadNapok );
// [KE, CSU, SZO, VAS]
munkaNapok ); // [HE, KE, SZE, CSU, PE]
Termszetesen az EnumSet osztly is tmogatja a generikus tpusokat

(bvebben lsd: 9.4.), gy az albbi definci is hasznlhat:
EnumSet <Napok> foglaltNapok = EnumSet.<Napok>of(Napok.HE,
Napok.SZE, Napok.PE);
9.3.2. Listk
A lista adatszerkezet szekvencilis adattrolst tesz lehetv. A listkban

az elemsorrend rgztett, valamilyen bejr algoritmussal vgigjrhatjuk az
elemeket. A listk bels adattrolsa trtnhet referenciatmbkkel, egy-s
ktirny listkkal.
ArrayList
A listt egy olyan dinamikus tmbbel reprezentlja, amely futsi idben
jramretezhet. A megvalstsban a kontner egy referenciatmbt
takar. A lista memriban foglalt mrett a kapacitsa (capacity), a benne tallhat elemek mrett a size adattagban trolja. Amennyiben a mret
elri a kapacitst, akkor a virtulis gp a listnak j s nagyobb helyet foglal a httrben.
A lista karbantart mveletei: elem hozzadsa (add), elem trlse
(remove), teljes lista trlse (clear), tartalmazs vizsglat (contains),
keress (indexof), elem elrse (get), elem cserje (set) stb.
Vector
A Vector osztly olyan kollekci, amely objektumok rendezetlen trolsra kpes, az ArrayList-hez hasonl mdon (dinamikus tmb). A Vector
abban tr el az ArrayList-tl, hogy az adatokat szinkronizltan kezeli,
ennek nagy szerepe lesz a prhuzamos, tbbszl programok fejlesztsekor, hiszen ott szksg van a minden egyes szlbl elrhet kontner objektumokra.
Helyezznk el tglalap objektumokat egy vektorban!
Vissza
155
Programozs III.
Vissza
156
Az elzekben definilt Teglalap osztly felhasznlsval, pl. az albbi

programrszlet segtsgvel elksztnk egy vektort:

List v1= new Vector();
v1.add(t1);
v1.add(t2);
v1.add(t2);
// Egy konstrukcival ltrehozott objektum kzvetlen
// (referenciavltoz nlkli) hozzadsa a kontnerhez.
v1.add(new Teglalap(12,4));
// A vektor 3. elemt eltvoltjuk.
v1.remove(2);
System.out.println("A vektor elemei:\n"+v1);
//Kimenet:
//A vektor elemei:
//[Tglalap [5.0,6.0], Tglalap [4.0,4.0], Tglalap
//[12.0,4.0]]
Az elz pldban kifejtett elv szerint List tpusnak deklarlt v1 vektorba az elemek referencijnak megadsval tehetnk elemeket. Azonban
kzvetlenl is adhatunk elemet a vektornak, egy konstruktor megadsval.
Ekkor a referencit csak a vektor mveletein keresztl rhetjk el. A programrszlet vgn a vektor tartalmt egyszeren kiratjuk a vektor
toString metdusn keresztl (automatikus konverzi), amely sorra bejrja a vektor elemeit, s azok toString metdusaival lltja el az
eredmnysztringet.
Stack
A Vector osztly leszrmaztatsval elll Stack osztly egy verem
rendszer adattrolt (LIFO last in first out) reprezentl. A kiterjeszts
sorn t j metdust vezet be az adatmanipullshoz. A push s pop metdusok segtsgvel lehet a verem tetejre egy elemet elhelyezni, illetve
levenni. A peek metdus segtsgvel a verem tetejn lev elemet felhasznlhatjuk, anlkl, hogy a verembl kivennnk. A veremben kikereshetnk
egy rtket (search) s megvizsglhatjuk, hogy res-e (empty).
Vissza
156
Programozs III.
Vissza
157
Adjunk meg a fenti pldra verem reprezentcit. Az elemeket fordtott

sorrendben adjuk vissza!
Stack verem= new Stack();

verem.push("A verem els eleme");
verem.push(t1);
verem.push(t2);
verem.push(t2);
verem.push(new Teglalap(12,4));
verem.push("A verem utols eleme");
System.out.println("A verem tartalma: ");
while (!verem.empty()){
System.out.println((verem.pop()));
}
//Kimenet:
//A verem tartalma:
//A verem utols eleme
//Tglalap [12.0,4.0]
//Tglalap [4.0,4.0]
//Tglalap [4.0,4.0]
//Tglalap [5.0,6.0]
//A verem els eleme
A pldbl lthatjuk a verem mkdsi elvt: az utoljra betett elemet

kapjuk meg elsknt. Az is ltszik a megadson, hogy a kontnerek klnbz tpus elemeket is tartalmazhatnak. (Itt nem hasznltuk ki a
magasszint modellekbl kapott lehetsgt, azaz azt, hogy a kontnert
interfsz segtsgvel definiljuk, hiszen a verem specilis metdusait is el
kellett rnnk tpusknyszerts nlkl.)
LinkedList
A List interfsz dinamikus, ktirny lncolt listval implementlt osztlya. Az egyes objektumok ssze vannak kapcsolva, azaz minden elem tartalmazza az t megelz, illetve kvet elem referencijt.
A lista els s utols eleme kitntetett szereppel br, hiszen mindketttl elkezdhetjk a lista bejrst. Adatkarbantart mveletei az ltalnos
listamveleteken kvl: addFirst, addLast, getFirst, getLast,
removeFirst, removeLast. Ezek a mveletek kiemelten kezelik a lista
Vissza
157
Programozs III.
Vissza
158
els s utols elemt. (A LinkedList megvalstja a Queue interfsz metdusait is, kifejtst lsd albb.)
Troljunk szveges adatokat egy ktirny listban!
List list = new LinkedList();
list.add("a nyri");
list.add("nap");
list.add(0,"le");
list.add(0,"Tzesen");
list.add(1,"st ");
// Tpusksnyszertssel elrhetek a LinkedList sajt
metdusai is:
((LinkedList)list).addLast("sugra.");
// Lista bejrsa egy specilis interfsz segtsgvel:
ListIterator it = list.listIterator();
while (it.hasNext()) {
System.out.println(it.next());
}
//Kimenet:
//Tzesen
//st
//le
//a nyri
//nap
//sugra.
9.3.3. Sorok
Adatsorok (Queue) kezelshez hasznlt sorok (FIFO trol first in first

out) annyiban trnek el a hagyomnyos listktl, hogy az adatkarbantart
mveleteik (beszr, kivtel, keress) specilisan mkdnek. j elemeket
ltalban a sor vgre helyezhetnk (add). A sor elejrl egy elem levehet
(poll), vagy a sor els eleme elrhet (peek) stb. A sorokat tulajdonkppen egy-egy specilis listnak is felfoghatjuk.
LinkedList
Az elzkben ismertetett LinkedList osztly implementlja a Queue
interfsz metdusait is, teht felfoghat egy sor-jelleg adattrolnak is
(FIFO). Ilyenkor a sorokra jellemz adatkezel mveleteket is hasznlhatjuk (add, poll, peek).
Vissza
158
Programozs III.
Vissza
159
PriorityQueue
Egy olyan sor kezelsre van lehetsgnk, amelyet valamilyen szempont
szerint rendeznnk kell.
A rendezs felttele, hogy a sorba illesztett elemeknek sszehasonlthatak legyenek, vagyis a TreeeSet s TreeMap osztlyoknl is hasznlt
Comparable interfszt implementljk. Egy adott elem a hozzadsakor
egybl a rendezsi szempont szerinti megfelel helyre kerl. A sor hossza
tetszleges lehet.
(Az egyidej konkurens programozsi feladatokban hasznlnak mg specilis osztlyokat, amelyek sklzhatk, hibatrk: ArrayBlockingQueue,
DelayQueue, PriorityBlockingQueue, LinkedBlockingQueue s
SynchronousQueue, de ezekkel ebben a jegyzetben nem foglaklozunk.)
9.3.4. Lekpezsek
A lekpezsek, vagy hozzrendelsek olyan specilis tpus kontnerek,

amelyekben kulcs-rtk prok segtsgvel trolhatunk elemeket. Minden
kulcshoz egy s csakis egy rtk tartozhat. A lekpezsek alapmveletei a
listkhoz, sorokhoz s a halmazokhoz hasonlk (get, put, clear, stb). A
Map nterfsz a Java rgebbi verziiban meglev Hashtable osztlyt vltotta fel.
A trols mdja a kvetkez: a lekpezs az egyedi kulcsrtkekhez
egy-egy troland objektum referencijt (rtkek) rendeli hozz. A kulcsrtkek trolsi mdja ezen a szinten mg nincs meghatrozva, de a kulcsok egyedisgt a megvalst osztlyoknak biztostani kell. A hozzrendels egyirny lekpezs, gy csak kulcs-rtk irnyban lekrdezhet.
Amennyiben egy kulcshoz egy jabb put metdussal egy j rtket rendelnk hozz, a rgebbi hozzrendels elveszik.
HashMap
A Map interfsz megvalstsa hasttbla segtsgvel. Az adatok elhelyezshez a put metdust hasznlhatjuk, amelyben az adott kulcshoz rendelhetnk rtkeket (pl. nevekhez letkor adatot) s a get metdus segtsgvel rhetnk el egy kulcshoz tartoz bejegyzst.
Az egyes adatmanipull mveletek a kulcsrtkek alapjn rik el az
adatokat. (Az rtkek elrst nem szabad sszekeverni az indexelssel,
hiszen az adatszerkezet nem szekvencilis. A hastsi technika a kulcsrtket tulajdonkppen egy fggvnnyel elll rtke szerint azonostja. A
hastfggvnyek mkdst bvbben lsd: 0. fejezet.)
Vissza
159
Programozs III.
Vissza
160
TreeMap
A Map interfsz implementcija rendezett fa adatszerkezet segtsgvel
gy, hogy a kulcsoknak sszehasonlthataknak kell lennik. Az sszehasonlts hasonl a TreeSet-ben alkalmazotthoz. A kulcsknt szerepl
objektumoknak implementlniuk kell a Comparable interfszt. A kulcsrtk prok ebben az osztlyban is a put s a get metdussal kezelhetk.
A kulcsok a keySet, a hozzrendelt rtkek pedig az entrySet metdussal halmazknt kln-kln is lekrdezhet.
Troljunk lekpezsek segtsgvel neveket a hozzjuk tartoz letkorral
egytt, nvsorba rendezetten.
Map szemelyek = new TreeMap();
szemelyek.put(Pisti, 17);
szemelyek.put(Bla, 43);
szemelyek.put(Dezs, 60);
szemelyek.put(Dezs, 71);//a rgi hozzrendels elveszik!
// kirs kulcsok szerint
System.out.println (Kulcsok: +szemelyek.keySet());
// kirs rtkek szerint
System.out.println (rtkek: +szemelyek.values());
// kirs egytt
System.out.println (A teljes lekpezs: +szemelyek);
// vizsglatok:
System.out.print("Van Pisti nev kulcs? ");
if (szemelyek.containsKey("Pisti")){
System.out.println("Igen.");
System.out.println("rtke:"+szemelyek.get("Pisti"));
}
else System.out.println("Nincs!");
//Kimenete:
//Kulcsok: [Bla, Dezs, Pisti]
//rtkek: [43, 71, 17]
//A teljes lekpezs: {Bla=43, Dezs=71, Pisti=17}
//Van Pisti nev kulcs? Igen.
//rtke:17
IdentityHashMap
A HashMap osztly egy alternatvja. Ebben a ritkn hasznlt osztlyban a
kulcsrtkek referencii szerinti sszehasonlts vgezhet el.
Vissza
160
Programozs III.
Vissza
161
LinkedHashMap
A lekpezst egy ktirnyban lncolt listban tartja. ltalban lekpezsek
msolathoz hasznljk, mert a lekpezs a fizikai felvtel sorrendjt megtartja.
EnumMap
Enum tpus felsorolt adatokhoz hasznlhat lekpezs. Az adatokat specilis tmbkben helyezi el. Tmr adattrolst tesz lehetv.
Az EnumMap osztly a specilisan felsorolt tpusok hozzrendelshez
hasznlhat. Segtsgvel nagyon knnyen tudunk a felsorolt tpus alap
hozzrendelseket, vagy indexelseket megadni.
A tpus definilshoz fel fogjuk hasznlni a felsorolt tpus osztlyt,
mint inicializtort, tovbb a generikus tpusokat(a generikus tpusokkal
bvebben a 9.4. fejezetben tallkozunk), a fordtsi idej tpusellenrzsek
miatt az albbi formban:
EnumMap<Kapcsolat, String> kapcsolatLeiro =
new EnumMap<Kapcsolat, String>(Kapcsolat.class);
Vagyis a kapcsolatLeiro egy olyan objektum lesz, amelyik a felsorolt

tpus konstans rtkekhez egy-egy szveges adatot rendel. A lekpezs
kezdetben res s a feltltst a mr lekpezseknl trgyalt put metdussal vgezhetjk el:
kapcsolatLeiro.put(Kapcsolat.HIBA, "A kapcsolat nem plt
fel!");
Az EnuMap tpus hasznlata ezutn analg a tbbi Map tpussal.

9.3.5. Az Iterator s az Enumeration
Az Iterator interfsz segtsgvel egy olyan objektumot nyerhetnk,

amelyek az egyes kontnerekben tartalmazott elemsorozat msolatt tartalmazza. Az itertor segtsgvel az adatszerkezetek referenciirl a memriban egy j, ideiglenes sorozat kszthet, segtsgvel a kontnerek
(tulajdonkppen a benne trolt elemek) bejrhatak, fggetlenl attl,
hogy a kontner milyen trolsi mdszer szerint trolja az adatokat.
Egy itertor az Enumeration interfsszel, vagy pedig az jabb fejleszts Iterator interfsszel adhat meg. Minden kollekci jelleg osztly
implementlja az iterator() metdust, s segtsgvel egy kollekci
Vissza
161
Programozs III.
Vissza
162
helyesen bejrhat. Az itertor alkalmazsval egy olyan objektum jn

ltre, amely gyakorlatilag egy bejrhat referenciasorozat.
Megjegyzs: Az interfsz tpus visszatrsi tpus metdusok olyan nvtelen (leszrmazott) osztlyokat hoznak ltre, amelyek az adott interfszeket megvalstjk.
Az itertorban hrom metdust hasznlhatunk: a hasNext() megadja,
hogy az itertornak van-e mg kvetkez eleme, a next() visszaadja a
kvetkez elem referencijt, a remove() kiveszi a referencit az
itertorbl anlkl, hogy az eredeti kollekcit mdostan.
(A Map interfszt megvalst lekpezsek kzvetlenl nem iterlhatak, csak a kulcs-rtk adataik kln-kln.)
Hozzunk ltre egy listt, melyben egsz rtkeket trolunk, majd egy
itertor segtsgvel listzzuk ki.
ArrayList lista = new ArrayList();
for (int i=0; i<20; i++){
lista.add(i);
}
Iterator it = lista.iterator();
System.out.println("A trolt rtkek:");
while (it.hasNext()){
System.out.print( it.next());
}
Az elzekben lthattunk egy pldt a ListIterator interfszre is, amely

a dinamikus listk bejrst teszi lehetv (lsd 0. fejezet).
A Java rgebbi kiadsaiban szerepl Enumeration interfsz mkdse
hasonl elven mkdik, mint az Iterator, azonban nem tartalmaz
remove metdust, ezrt hasznlata a fejlesztk szerint mr nem ajnlott,
br kompatibilitsi szempontok miatt mig a krnyezet rsze maradt.
for (Enumeration e = v.elements() ; e.hasMoreElements() ;){
System.out.println(e.nextElement());
}
Vissza
162
Programozs III.
Vissza
163
9.4. ltalnostott tpusok (generics)

A Java fejleszti krnyezet kiadsnak 5. verzijban [12] szmos j elem
jelent meg, amelyek kzl a legltvnyosabb az ltalnostott tpusok s
metdusok megjelense (generic type, generic method).
A fejlesztk mr Java krnyezet tervezsekor azt a clt tztk ki, hogy
a hibalehetsgek a lehet legkorbban, lehetleg mg fordtsi idben
derljenek ki. A generikus tpusok bevezetse is ezen filozfia rsze.
Ms megkzelts szerint [Nyky03, 694.p] a generikus tpusok hasznlata az adatszerkezetek s algoritmusok absztrakcijval, az absztrakt mdon megfogalmazott feladatkirs egy hatkony kdolst tkrzi, melyben elvonatkoztathatunk a lnyegtelen rszletektl.
A generikus tpusok hasznlathoz a nyelv egyes elemeit kiterjesztettk. gy definilhatk olyan osztlyok, melyek adattagjai ill. metdusainak
paramterei vagy visszaadott rtkei ltalnostott (helyettesthet) tpusokkal lthatk el.
9.4.1. Generikus tpusok hasznlata
Az ltalnostott tpusok legtbbet hasznlt, s legtbbszr bemutatott

pldja a lncolt listk osztlya. A List interfszrl a kvetkez bejegyzst talljuk az API-ban: java.util.List<E>. Az <E> formula jelli,
hogy a List interfsz s minden megvalstsa generikus tpusokat
kezel. Itt maga az E jelli azt a konkrt tpust, amelyet majd a listban trolni kvnunk. A lersban tbbszr is tallkozunk az <E> szimblummal,
pl. a void add(<E> o), vagy az <E> get() metdusnl. A jellsben itt
az E, mint helyettestend tpus ll.
Vagyis lehetsg nylik olyan absztrakt, kontner jelleg adatszerkezetek megfogalmazsra, melynek definilsakor mg nem ismerjk a trolni
kvnt osztlyok tpust. A tpust elegend csak a konkrt listaobjektum
pldnyostsakor rgzteni. Ekkor az <E> szimblumok a kvnt tpussal
helyettestdnek.
Hozzunk ltre egy olyan ktirnyban lncolt listt, amely csak String
tpus elemeket tartalmaznak!
Vissza
163
Programozs III.
Vissza
164
public static void main(String[] args(){

//Generikus tpus vltoz definilsa
LinkedList<String> szavak = new LinkedList<String>();
// adatfeltlts
szavak.add(els);
szavak.add(msodik);
szavak.add(1234); // fordtsi hiba!
szavak.add(new Teglalap(3,4)); //fordtsi hiba!
System.out.println(szavak); //kimenet: [els, msodik]
System.out.println(szavak.get(1)); //kimenet: msodik
//Nincs szksg tpusknyszertsre!
String s = szavak.get(0);
}
A generikus tpusok hasznlatnak tbb elnye is van:

A fordt mr fordtsi idben ellenrzi a generikus tpusokban hasznlt
helyettestend tpust (a pldban a String tpust), s az objektumok
pontos metdushvst is. gy sok futsidej ClassCastException tpus kivtel elfordulsa eleve elkerlhet. Az egyes paramterek s a
visszatrsi rtkek tpusa rgztett s ellenrizhet.
A generikus tpusok hasznlatakor a fordt mr ismeri a konkrt tpust, ezrt a sorozatos tpusknyszerts (ami sokszor az tlthatsgot
nehezti) is elhagyhat. Tovbb a hasznlt tpusnak a leszrmazottjai
is felhasznlhatak lesznek.
A Java keretrendszer 1.4-es kiadsa mg nem tmogatta a generikus tpusokat, gy pl. egy lncolt listt csak a legltalnosabb referenciatpusokkal
tlthettnk fel (Object), s a felhasznls sorn az egyes trolt objektumok metdusait csak tpusknyszertssel rhettk el. Mg bonyolultabb
volt a helyzet abban az esetben, ha az osztly kellen sszetett adatszerkezettel brt. Ilyenkor egy sorban nemegyszer kt-hrom, vagy tbb tpusknyszerts is elfordulhatott, ami gyakorlatilag olvashatatlann tette a
kdot. A generikus tpusok hasznlatval ez kikszblhet.
Ksztsnk lekpezst, melyben egsz rtkekhez szveges adatokat rendelhetnk! (Oldjuk meg a feladatot vals szmokkal is!)
Vissza
164
Programozs III.
Vissza
165
//Egsz szmokkal
Map <Integer, String> hozzarendeles1 =
new HashMap <Integer, String>();
hozzarendeles1.put(1, "els");
hozzarendeles1.put(2, "msodik");
hozzarendeles.add(3.14, "Pi"); //fordtsi hiba!
System.out.println(hozzarendeles1);
//ltalnos szmformtummal
Map <Number, String> hozzarendeles2 =
new HashMap <Number, String>();
hozzarendeles2.put(1, "els");
hozzarendeles2.put(2, "msodik");
hozzarendeles2.put(3.14, "Pi"); // OK.
System.out.println(hozzarendeles2);
A generikus tpusok egymsba gyazhatk, gy egy kellen sszetett adatszerkezet is knnyen kezelhet lesz.
Az albbi pldban egy olyan sszetett adatszerkezetet definilunk, amelyben egsz szmokbl ll tmbket lncolt listban helyeznk el, s ilyen
listbl kulcs-rtk prokkal lekpezseket ksztnk. (Hasonl mdon
ms adatszerkezetek is felpthetk.)
// Egszekbl ll tmbkbl egy ktirnyban lncolt listt
ksztnk,
// majd a listt behelyezzk egy lekpezsbe
int [] a = {0,1,2,3,4};
int [] b = {10,11,12,13,14,15 };
int [] c = {20,21,22,23,24,25,26,27};
// lista elksztse
List <int[]> szamlista = new LinkedList<int[]>();
szamlista.add(a);
szamlista.add(b);
szamlista.add(c);
// a lista tartalma, egyszerstett hozzfrs:
System.out.println("A lista tartalma:");
for (int i=0; i < szamlista.size(); i++){
for (int j=0; j < szamlista.get(i).length; j++) {
System.out.print(szamlista.get(i)[j]+", ");
}
}
Vissza
165
Programozs III.
Vissza
166
//A lista elhelyezse a megfelelen elksztett

hozzrendelsbe/lekpezsbe
//itt jl megfigyelhet a generikus tpusok egymsba
gyazdsa
Map <String, List<int[]>> hozzarendeles =
new HashMap <String, List<int[]>>();
//Az "Els" kulcshoz hozzrendeljk a szamlista
// lncolt listt (amely maga is tmbkbl ll)
hozzarendeles.put("Els", szamlista);
//Az "Els" kulcshoz hozzrendelt lista els tagjnak
// msodik eleme a kvetkezkppen rhet el:
// nem szksges tpust knyszerteni,hiszen
// a defincibl a tpusok egyrtelmen addnak!)
System.out.println(hozzarendeles.get("Els").get(0)[1]); //
kimenet: 1
hozzarendeles
Map <String, List<int[]>>
"Els" =
... = ...
...
szamlista
(0.)
(1.)
LinkedList <int[]>
(2.)
NULL
NULL
int[]
c[]
b[]
a[]
10
1
11
3
20
21
22
23
12
13
14
15
24
25
26
27
hozzarendeles.get("Els").get(0)[1]
23. bra: Generikus tpusok hasznlata sszetett adatszerkezetekben
Vissza
166
Programozs III.
Vissza
167
A kollekci keretrendszer hasznlatval egy fordtsi idben ellenrztt, a

futsidej hibkra kevsb rzkeny kd llthat el. A tpuskonverzit
az adatszerkezetek definilsakor megadott tpusok szerint a fordt automatikusan elvgzi. A fordt azonnal figyelmeztet zenettel, vagy hibval jelzi a nem megfelel tpushasznlatot, mg a generikus tpusok nlkl
esetleg egy tvolabbi helyen kapnnk futsidej kivtelt.
Termszetesen a fenti plda mg nem tkletes, csak a tpusok egymsba gyazhatsgt mutatja be, ugyanis a tmbk s a lista nem megfelel indexelse kivlthat mg futsidej kivtelt. Ezrt clszerbb lenne
egy megfelel osztlyt megfelelen ellenrztt metdusokkal definilni, de
terjedelmi korltok miatt itt erre most nem trnk ki.
9.4.2. Generikus osztlyok definilsa
A fentiekben lttuk, hogy egy generikus tpust hogyan kell felhasznlni. Az

albbiakban megismerkednk a generikus tpus defincikkal, azaz azzal,
hogy hogyan kszthetnk olyan ltalnostott osztlyokat, melyek majd
csak a pldnyostskor kapnak konkrt tpusokat.
Az alapelv nagyon egyszer. Az albbi pldkban a <V> s a V szimblummal jelljk a helyettestend ltalnos tpust. Az ABC nagybetivel
jelzett tpus az osztly pldnyostsakor kapja majd meg azt a konkrt
tpust, amelyet helyettesteni fog. Ekkor a fordt a szimblumok helyre a
konkrt tpust rendeli s ezzel a valdi tpussal hozza ltre a bjtkdot
(.class).
Definiljunk egy N-g ft ler tpust generikus tpusokkal!
import java.util.*;
public class TobbaguFa<V>{
//A fa egy csompontjnak rtke
private V ertek;
//A fa gai, mint egy dinamikus referenciatmb
private List <TobbaguFa<V>> agak =
new ArrayList<TobbaguFa<V>>();
//Konstruktor
public TobbaguFa(V ertek){
this.ertek=ertek;
}
Vissza
167
Programozs III.
Vissza
168
//Metdusok
V getErtek(){ return this.ertek;}
void setErtek(V ertek){ this.ertek=ertek;}
int getAgakSzama(){ return agak.size();}
TobbaguFa<V> getAg(int n){ return agak.get(n);}
void addAg(TobbaguFa<V> ujag){ agak.add(ujag);}
}
public class NFaTeszt{
public static void main(String[] args){
TobbaguFa <String> gyoker =
new TobbaguFa<String>("Gykr");
//Adatfeltlts
gyoker.addAg(new TobbaguFa<String>("1_Bal"));
gyoker.addAg(new TobbaguFa<String>("1_Kozep"));
gyoker.addAg(new TobbaguFa<String>("1_Jobb"));
gyoker.getAg(0).addAg(new TobbaguFa<String>("2_Bal Bal"));
gyoker.getAg(0).addAg(new TobbaguFa<String>("2_Bal Kzp"));
gyoker.getAg(0).addAg(new TobbaguFa<String>("2_Bal Jobb"));
gyoker.getAg(1).addAg(new TobbaguFa<String>("2_Kzp Bal"));
...
}
}
Gykr
1_Bal
2_Bal
Bal
2_Bal
Kzp
1_Kzp
2_Bal
Jobb
1_Jobb
2_Kzp
Bal
24. bra: N-g fa szerkezeti modellje

Amennyiben a generikus osztlyok pldnyostsbl elhagyjuk a generikus tpus pontostst (<Tpus>), akkor a fordt ezt Note: ....java
uses unchecked or unsafe operations. Note: Recompile with
-Xlint:unchecked for details. figyelmeztet zenettel jelzi. A
Vissza
168
Programozs III.
Vissza
169
figyelmeztets kikapcsolhat, (pldul korbbi Java verzira rt forrsokhoz), ha a fordtst az -Xlint:unchecked opcival vgezzk.
9.4.3. Generikus tpusok korltozsai
Abban az esetben, ha valamennyire konkretizlni szeretnnk a tpust, vagy

a definci tl ltalnos, akkor megadhatunk korltozsokat is. Erre az
extends kulcssz hasznlhat, korltknt pedig megadhat egy osztly,
illetve tetszleges szm interfsz (& jelekkel sszefzve). Ekkor a generikus tpusbl csak a megadott osztly vagy annak leszrmazottjai szerint
pldnyosthatunk.
Abban az esetben, ha a generikus tpus korltozsakor interfszeket is
megadtunk, akkor a pldnyostskor a fordt megkveteli az interfszek
megvalstst is. Ekkor a tpust ler osztlyt az albbi mdon definilhatjuk:
public class TobbaguFa<V extends Number>{...}
public class TobbaguFa<V extends Number & Comparable>{...}
Azaz a TobbaguFa osztlyban olyan tpusokat hasznlhatunk, amelyek a

Number csomagol osztly leszrmazottai s megvalstjk a Comparable
interfszt. Ekkor az osztlyban megadhatunk pl. rendezsi metdusokat is.
A korltozsokat termszetesen az adott feladathoz kell igaztani.
9.4.4. Generikus metdusok
Abban az esetben, ha egy metdusnak olyan paramtert kvnunk adni

amely a fenti generikus tpusokat kezeli, akkor ezt korltozs nlkl megtehetjk az albbi szintaktika hasznlatval: public
void
listakezeles(List <E> lista){}, mint generikus tpus paramter,
vagy public List<E> getLista(){}, mint visszatrsi tpus, s ahol E
helyn brmely ismert interfsz, vagy osztlyazonost llhat.
A TobbaguFa osztlyban ilyen metdus volt maga a konstruktor is, illetve nhny metdus is (pl: getErek(), addAg()).
Az egyik elz pldban hasznlt egsz tmbkbl ll listhoz rjunk
megjelent metdust!
Vissza
169
Programozs III.
Vissza
170
public void listaTartalma(List <int[]> lista){

for (int i=0; i < lista.size(); i++){
for (int j=0; j < lista.get(i).length; j++) {
System.out.print(lista.get(i)[j]+", ");
}
}
}
9.4.5. Hatrozatlan tpusparamterek
A generikus tpusok definilsnl azonban sok esetben nem tudjuk elre

megadni a korltozsokat, vagy a tpust eleve absztraktnak tervezzk. Ekkor a <?> joker tpust hasznlhatjuk. Az elz pldkban az <E> vagy <V>
hasznlatakor az egyes felhasznlsi helyeken ktelez volt a tpusegyezs
(a betk helyre a fordt helyettesti a konkrt tpust). Sokszor azonban
ennl lazbb defincira van szksgnk. Pldul egy osztlyhierarchia
osztlyaibl szeretnnk valamilyen fejlett adatszerkezetet megadni.
public class TobbaguFa<V>{
private V ertek;
private List TobbaguFa<? extends V>> agak =
new ArrayList<TobbaguFa<? extends V>>();
Ekkor a fa egyes csompontjaiban nemcsak a V objektumok, hanem annak leszrmazottai is lehetnek.

9.5. Krdsek
Hogy csoportosthatjuk az adatszerkezeteket?

Hol hasznlhatjuk a kontner osztlyokat?
Melyik csomagban tallhat a gyjtemny keretrendszer?
Melyek a halmaz adatszerkezet fbb jellemzi?
Melyek a dinamikus tmb adatszerkezet fbb jellemzi?
Melyek a lista adatszerkezet fbb jellemzi?
Melyek a lekpezs (hozzrendels) adatszerkezet fbb jellemzi?
Mi a klnbsg egy sor s egy verem trol kztt?
Mire szolgl az Iterator osztly?
Mire hasznlhatak a generikus tpusok?
Mi a klnbsg a generikus tpus, a generikus metdus kztt?
Vissza
170
Programozs III.
Vissza
171
9.6. Feladatok
Ksztsen pldaprogramot, melyben egy Vllalat (cgnv, vezet,
alkalmazottak, tevkenysgi kr) szemlyi nyilvntartst vezetjk. A
vllalatnl egy cgvezet s szmos Alkalmazott (nv, szemlyi ig.
szm, letkor) adatait tartjuk nyilvn. A Vllalat megalakulsakor a
cgvezet mr ismert. Az alkalmazottak trolst valamilyen kontner
osztly segtsgvel oldja meg! A program legyen kpes:
ismertetni a vllalat sszes dolgozjnak adatait nv szerinti abc
sorrendben,
letkor szerinti cskken sorrendben,
az sszes dolgoz letkort egy vvel megnvelni,
felvenni s elbocstani alkalmazottakat.
Ksztsen pldaprogramot, amelyben halmaz adatszerkezetekben trolja emberek csoportjait. Az els csoport legyen a Lakk, tagjai a kvetkezk: Bla, Tni, Gza, Jzsi, Andi. A Bolt dolgozi a kvetkez
szemlyek: Andi, Dezs, Gza. A kzeli Szervz dolgozi: Andi, Jzsi, Tni.
Jelentse meg azokat a szemlyeket, akikre igazak az albbi megllaptsok:
aktv dolgozk,
munkanlkliek,
tbb helyen is dolgoznak,
azok a dolgozk, akik nem laknak a krnyken.
Ksztsen olyan programot, amely rendezetlen lekpezsben a kvetkez adatokat tartja nyilvn:
hallgatk neve s pontszm,
becenevek s szemlyi adatokat tartalmaz objektunmok.
Vissza
171
Programozs III.
Az I/O s hlzatkezels
Vissza
172
10. Az I/O s hlzatkezels

A legegyszerbb programok is kommuniklnak a klvilggal. Egy karakter
megjelentse a kpernyn, vagy beolvassa a billentyzetrl; a fjl s hlzatkezels, illetve az adatbzisok elrse a Java nyelvben hasonl koncepci szerint zajlik. Az adatok valahonnan rkeztetse, illetve valamilyen
clba eljuttatsa ltalnosan az adatfolyamok (stream) segtsgvel zajlik.
Az adatfolyamok egy adott adathalmazt (pl: karakter, bjt, objektum) kpesek szabvnyosan fogadni, illetve az adott clba eljuttatni. Ezen az elven
mkdik az eddig hasznlt System.out.println() hvs is.
A Java keretrendszerben a java.io csomagban definiltk a folyamkezelst s a fjlkezelst megvalst osztlyokat. A csomag hasznlathoz
be kell jelentennk a fordtsi egysgek import deklarcis rszben:
import java.io.*;
(A java.nio csomagban definilt pufferelt, sklzhat ki s bemenettel

itt nem foglalkozunk.) A Java krnyezet gazdag osztly- s interfszknlata lefedi a legtbb olvassi s rsi feladatot. Az albbiakban ezekkel ismerkednk meg.
A fjlok elrse s kezelse a File osztly segtsgvel lehetsges.
Minden egyes File tpus objektum egy-egy fjlrendszerbeli elemet reprezentl. Az objektumokat tvonalukkal azonostjuk. A File osztly segtsgvel a fjlrendszer bejrhat, a fjlok tnevezhetek, trlhetek, attribtumaik mdosthatk s res llomnyok is ltrehozhatk. A fjlok
elrshez relatv, vagy abszolt tvonal megadsval juthatunk el. Az
albbi megadssal az aktulis knyvtrhoz viszonytott relatv tvonalat
adtunk meg:
File f = new File(ikonok/javalogo.gif);
A File.separator statikus adattagban az adott opercis rendszerhez tartoz fjl elvlaszt karaktert tartja. Ennek segtsgvel az elbbi tvonalat
ikonok+File.separator+javalogi.gif-knt megadva hordozhatv tehetjk a kdot.
Listzzuk ki az aktulis knyvtr sszes txt kiterjeszts fjljt!
Vissza
172
Programozs III.
Vissza
173
import java.io.*;
public class listazas {
public static void main( String[] args )
throws IOException {
File knyvtr = new File(".");
// nvtelen bels osztly alapjn szrnk
File [] fjlok = knyvtr.listFiles(new FileFilter(){
public boolean accept( File tvonal ){
return (tvonal.isFile()
&& tvonal.getName().endsWith(".txt"));
}
} ); //listFiles vge
for( int i=0; i<fjlok.length; i++ ){
System.out.println(fjlok[i].toString());
}
}
}
Trljnk egy adott fjlt a fjlrendszerbl!

import java.io.*;
class Torles {
public static void main(String args[]) throws IOException{
File trlend = new File("torlendo.txt");
if( trlend.canWrite() ) {
trlend.delete();
}
}
}
10.1. Adatfolyamok
A folyam (stream) egy olyan objektum, amely adatokat kpes rni, illetve
olvasni egy adott clhelyre, illetve clhelyrl. A folyamok hasznlatakor a
felhasznl nem szleli a mgttes hardver elemek sajtossgait, gy az egy
hatkony, magas szint s rugalmas ki- s bemenetet biztost programozsi szempontbl. Az adatfolyamok segtsgvel a kimenet clja, vagy a bemenet forrsa knnyen vltoztathat, a program sokoldalv tehet.
Vissza
173
Programozs III.
Vissza
174
A folyamkezels sorn az adatokat sorosan dolgozza fel a Java krnyezet (FIFO trolk). A folyamokat a bennk halad adatok szerint bjt-,
karakter-, (elemi tpus) adat-, illetve objektumfolyamnak is nevezhetjk.
Az adatramls irnya alapjn pedig beviteli (input) s kimeneti (output)
folyamokat szoks megklnbztetni.
25. bra: Adatfolyamok

A folyamok egymsba lncolhatak, gy egy-egy folyam egy msikba alakthat, illetve szrfolyamok (filter stream) segtsgvel az traml adatok pufferezhetek, szrhetek, vagy akr egy msik folyam szmra tkonvertlhatak.
A folyamkezels lpsei a kvetkezk:
Az adatfolyam megnyitsa (open).
Amg informci rkezik:
olvass az adatfolyambl, (ill. rs az adatfolyamba: read, write).
Adatfolyam lezrsa (close).
A folyamok megnyitst a megfelel osztly pldnyostsval rhetjk el.
Az elll objektumon ezutn a kvnt mveleteket elvgezhetjk, belertve a lezrst is.
Vissza
174
Programozs III.
Vissza
175
10.2. Kapcsolat a fjlrendszerrel

A Java keretrendszer io csomagjban az albbi osztlyhierarchit alaktottk ki. (Itt csak a legfontosabb s leggyakrabban hasznlt osztlyokat emeltk ki az tlthatsg kedvrt.)
Object
InputStream
ByteArrayInputStream
FileInputStream
FilterInputStream
DataInputStream
BufferedInputStream
ObjectInputStream
OutputStream
ByteArrayOutputStream
FileOutputStream
FilterOutputStream
DataOutputStream
BufferedOutputstream
ObjectOutputStream
Reader
InputStreamReader
FileReader
BufferedReader
LineNumberReader
CharArrayReader
Writer
OutputStreamWriter
FileWriter
BufferedWriter
CharArrayWriter
Az osztlyhierarchia tetejn az InputStream, az OutputStream, a

Reader s a Writer absztrakt osztlyok llnak. Az egyes specilis feladatokra szolgl osztlyok ezek valamelyiknek a leszrmazottjai.
Az InputStream, OutputStream osztlyok a bjtalap ki- s bemeneti folyamok ltrehozshoz kszlt. Itt az input/output (a tovbbiakban
I/O) alapegysge a bjt, vagyis minden jel 8 bites (0-255 rtk) lehet.
Vissza
175
Programozs III.
Vissza
176
A Reader, Writer osztlyok a karakteres I/O kezelsnek sosztlyai. Az

adatokat 16 bites unicode karakterknt rtelmezik. Tipikusan ilyen folyamok kezelik a billentyzetrl rkez s a kpernyre sznt adatokat. Az
osztlyok feladata a konverzi vgrehajtsa, amikor a unicode karaktereket
talaktja az adott fjlrendszer, (ill. az explicit kdkszlet megadsval) 8
bites brzolsi tartomnyra, illetve vissza.
Az osztlyok nevei beszdesek, hiszen a fenti ngy osztly minden leszrmazottja nevben viseli az sosztly alaptulajdonsgait. A folyamkezel osztlyok (a megvalstott interfszeknek ksznheten) hasonl nev
metdusokkal vezrelhetk pl: read, write, flush, close (azonos zenetklds).
A hierarchiban lefel haladva talljuk a ngy absztrakt osztlybl
szrmaz osztlyokat. A bjt s karakter alap osztlyok kztt nagyfok
szimmetrit fedezhetnk fel.
Az rs s olvass mvelete szmos hibalehetsget hordoz, hiszen itt
az adott hardverrel, vagy az opercis rendszer egyes rszeivel trtnik
kommunikci. Az IOException kivtelosztly, illetve ennek 20-25 alosztlya segtsgvel a kivteles esemnyek pontosan lekezelhetk (Az egyes
metdusokban vgrehajtott i/o mveletek eltt biztostani kell a kivtelek
kivltst a throws IOException utastssal, vagy egy try-catch szerkezettel.)
10.2.1. Adatfolyamok rsa, olvassa
Mint emltettk, a bjtfolyamok rshoz s olvasshoz az InputStream s

OutputStream osztly leszrmazottjait hasznlhatjuk. Az osztlyok definilnak egy-egy absztrakt read(), ill. write() metdust. Ezeken a polimorf mveleteken keresztl specializltk a leszrmazott osztlyok mkdst.
FileInputStream: fjlbl olvasst lehetv tev bjtfolyam. A
read metdus segtsgvel egy fjl tartalmt bjtonknt kiolvashatjuk a fjl elejrl folyamatosan. Ha a hivatkozott fjl nem ltezik
akkor a virtulis gp FileNotFoundException kivtelt hoz ltre.
FileOutputStream: egy adott fjlba r bjtfolyam. A write metdus segtsgvel egy fjlba folyamatosan bjtokat rhatunk. Ha a
fjlt nem lehet ltrehozni, akkor az FileNotFoundException kivtelt vlt ki.
Vissza
176
Programozs III.
Vissza
177
FilterInputStream, FilterOutputStream: Ez a kt osztly a

szr folyamok sosztlya. Az adattovbbtsban, mint kzbens
folyam, a bejv bjtsorozatot egy adott tpus bjtsorozatt, vagy
specilis mkds folyamm alaktja. A szrfolyamok csak egy
mr ltez folyambl llthatk el.
DataInputStream, DataOutputStream: Segtsgkkel egy folyam
valamilyen alaptpus, vagy sztring adatt konvertlhat. Az adatok
bjtfolyamm alaktsval egy msik folyamba rhatak lesznek. Nagyon gyakran hasznlt az egyes konverzis mveleteknl, vagy amikor a gpi adatbrzolst szeretnnk a kimeneten megjelenteni,
vagy beolvasni a readUTF, readBoolean, readChar, readInt
stb., illetve a writeBoolean, writeChar, writeInt stb. metdusok
segtsgvel.
BufferedInputStream, BufferedOutputStream: ezen szrfolyamok beiktatsakor a memriban trolt adatokat a kirs, vagy
olvass sorn egy tmeneti trolban sszegyjti (puffereli) lecskkentve az opercis rendszer szint r/olvas mveletek szmt.
A puffer mrete megadhat.
PushbackInputStream: hasznlatval lehetsgnk van egy adott
folyamra visszatenni, majd jra olvasni az adatokat (unread).
PrintStream: az adatfolyamra kzvetlenl kldhetnk karaktereket, azok a rendszer alapkdolsa alapjn automatikusan bjtsorozatt konvertldnak. A nyelv valamennyi adattpusval hasznlhat. Automatikus transzlcit vgez, azaz a sorvgjeleket az opercis rendszeren hasznlatoss konvertlja.
ByteArrayInputStream, ByteArrayOutputStream: az rkez adatok bjttmbkbe olvassra, ill. bjttmbk kirsra alkalmas.
PipedInputStream, PipedOutputStream: alkalmas n. csvek
kialaktsra. Segtsgkkel megszervezhetjk a prhuzamos programrszek kztti kommunikcit.
SequenceInputStream: a bemeneti csatornk sszefzsre s egyms utni feldolgozsra alkalmas.
ObjectInputStream, ObjectOutputStream: Ezen osztlyok klnlegessge, hogy az objektumokat s a referencikkal elrt adatokat
(tmbk, sztringek) is egy adott folyamba foglalhatjuk. Ennek a megvalstsnak a neve a szerializci (lsd: 10.2.3. fejezet).
Vissza
177
Programozs III.
Vissza
178
A kvetkez pldban az albbi egyszer r-olvas feladat megoldst

lthatjuk:
Msoljuk t a standard bemenetrl rkez karaktereket a kimenetre sorvgjelig! Oldjuk meg a feladatot pufferezetten is!
import java.io.*;
public class Olvasas {
public static void main( String[] args ){
try {
int b;
// Els eset: a bemenet tmsolsa a kimenetre:
System.out.println(
"A bemenet tmsolsa a kimenetre enter vgjelig:");
while (( b = System.in.read())!='\n')
System.out.write(b);
System.out.flush();
// Msodik eset:
// A standard bemenetrl pufferes folyamot nyitunk ->
// a bemenetet tirnytjuk a folyamba -> s visszarjuk
System.out.println("\nA bemenet tmsolsa pufferesen
a kimenetre enter vgjelig:");
BufferedInputStream in =
new BufferedInputStream(System.in);
while (( b = in.read())!='\n')
System.out.write(b);
in.close();
System.out.flush();
} catch (IOException e){
System.err.println(e);
}
}
}
Vissza
178
Programozs III.
Vissza
179
26. bra: Adatfolyamok egymsba gyazhatsga

Most jutottunk el odig, hogy az eddig gyakran hasznlt System.out objektumot megrtsk. Eddig a println metdussal zenetet kldtk,
hogy valamilyen szveges adatot megjelentsnk.
A System.out egy elre definilt kimeneti adatfolyam. A Java krnyezet a System vgleges osztlyban definilta az opercis rendszer
standard input, output s hibacsatornjnak elrst.
Ezek olyan osztlyszint adattagok, amelyek maguk is egy-egy folyamknt lteznek, gy a folyamok standard zeneteit ismerik s hasznljk.
Elszr egy int tpus vltozba bjtonknt beolvassuk a billentyzetrl
rkez adatokat (System.in), majd ezeket egyesvel kirjuk
(System.out).
A msodik esetben a bemeneti folyamot talaktjuk, s a bemeneti folyam segtsgvel ellltunk egy szrt adatfolyamot, amelyet a Java krnyezet pufferezetten kezel. Ezutn a kimeneti folyamba irnytjuk a bjsorozatot. Hiba esetn a standard hibacsatornra rjuk ki az zeneteket.
Az opercis rendszerben a standard bemeneti, kimeneti s hibacsatornk t is irnythatak. A kvetkez parancs hatsra:
java Olvasas <input.txt >output.txt 2>error.txt
a bemenetet az input.txt fjlbl veszi s a kimenetet az output.txt, a

hibkat az error.txt fjlban kapjuk.
Vissza
179
Programozs III.
Vissza
180
10.2.2. Karakteres rs-olvass
Szveges llomnyokkal amelyben az informcit karakterek sorozata

hordozza a Reader s a Writer absztrakt osztlyok leszrmazottjai
segtsgvel dolgozhatunk, melyek az alapmveleteket (read, write,
close) megvalstjk.
A szveges llomnyok soronknt olvashat ill. rhat informcikat
tartalmaznak. A sorok elvlasztst a sorvgjelek (EOL) segtsgvel trtnik, melyeket transzlcival kell feldolgozni. (A Unix (CR \n) s a
Windows (CR+LF \r\n) opercis rendszerek eltren kezelik a sorvgjeleket, ezen jelek klcsns talaktsa a transzlci).
Az llomnyokban rtelmezett egy fjlmutat jelleg index, amely lehetv teszi a fjlban trtn pozcionlst.
A leszrmazott osztlyok a bjt szint adatfolyamokhoz hasonl osztlyokat definilnak:
BufferedReader, BufferedWriter: ez a szrfolyam pufferezett
olvasst s rst tmogat, segtsgvel cskkenthetek az i/o rendszerhvsok, gyorsabb mkdst eredmnyez.
LineNumberReader: az adatllomnyt gy alaktja t, hogy a tbbszrs soremelseket elhagyja, majd a sorokat megszmozza.
CharArrayReader,
CharArrayWriter,
StringReader,
StringWriter: az adatfjlbl kzvetlenl karaktertmb illetve
sztring tpus folyamba olvashatjuk az adatokat.
FilterReader, FilterWriter: a szrfolyamok absztrakt osztlyai.
PushBackReader: ezzel a szrfolyammal egy folyambl kiolvasott karaktert szksg esetn visszatehetnk az adatfolyamba, majd
jra kiolvashatjuk.
InputStreamReader, OutputStreamWriter: ez a kt osztly jelenti
a hidat a karakteres s a bjt szint folyamok kztt. Egy adott bjtfolyam olvassakor egy adott karakterkdols szerinti konverzival
az rkez adatokat karakterekk konvertlja, s visszafel egy karaktersorozatot bjtsorozatt konvertl. A karakterkdols (ISO-8859-1,
ISO-8859-2, CP-852, CP-1250, UTF-8, US-ASCII stb.) karakterlnc
konstansok valamelyike lehet. Nagyon gyakori a pufferelt folyamokkal egyttes hasznlata. Nagyon fontos, hogy a programok r s olvas rszletei ugyanazt a kdolst hasznljk.
FileReader, FileWriter: leszrmazottknt ez a kt osztly is
bjt-karakterfolyamok kztti konverzira hasznlhat, azonban
Vissza
180
Programozs III.
Vissza
181
minden esetben az alaprtelmezs szerinti kdolst s alaprtelmezs szerinti puffermretet hasznl.

PipedReader, PipedWriter: a bjtfolyamokban trgyaltakhoz hasonlan csvekhez, a szlak kztti informcicserhez hasznlt
adatfolyam.
PrintWriter: ez a karakterfolyam rengeteg felltlttt print metdust
tartalmaz, gy hatkonyan formzott kimenetet rhetnk el ennek a folyamnak a felhasznlsval. Az alaptpusok mellett lehetsgnk van
referencia tpus vltozk szveges formban val megjelentsre.
Minden egyes jsor karakter utn automatikusan vgrehajtja a flush
metdust, s kicserli a soremels karaktereket az adott krnyezet
sorzr karaktereire (automatikus transzlci). Az adatfolyam mveletei sohasem vltanak ki IOException jelleg kivtelt.
Az albbi pldaprogram a karakteres kimenet kezelst mutatja be:
import java.io.*;
public class Szovegki {
public static void main( String[] args )
//rs a kimenet.txt fjlba FileWriter segtsgvel,
//automatikus szvegkonverzi
FileWriter f = new FileWriter("kimenet.txt") ;
//Az adott fjlhoz egy folyamot rendelnk
PrintWriter out = new PrintWriter(f);
out.write("A fjlba elkezdek szveget rni.");
out.print("Folytatom, \n s sort emeltem!\n");
out.println("gy is rhatok!");
//A JDK 1.5-tl mr a C-nyelvben megismert printf fggvny
//is hasznlhat:
out.printf("%20s %5d","De \"C\" szerint gy is:" ,300 );
//A folyam lezrsa
out.close();
}
}
szveges
adatok
feldolgozshoz
hatkonyan
hasznlhat
StreamTokenizer osztly. Nagyon hasonlt a szr jelleg folyamokra: a
bemeneti adatfolyam feldolgozsakor az adatfolyamot adategysgekre

bontja. Ezek az egysgek (token) lehetnek azonostk, szmok s sztring
Vissza
181
Programozs III.
Vissza
182
literlok. Hasznlata egyes nyelvi feldolgoz alkalmazsok gyors fejlesztst teszi lehetv. Az osztlyban konstansknt definiltk az egyes
tokenek rtkeit:
TT_EOF (-1)
TT_EOL (\n)
TT_NUMBER (-2)
TT_WORD (-3)
llomny vge,
sorvgjel,
szm jelleg adat,
szveg vagy azonost jelleg adat.
Egy szvegfjlbl olvassunk be sorokat s bontsuk fel klnll szavakra.

Jelentsk meg a standard kimeneten a szveg jelleg adatokat!
import java.io.*;
// a fjlbl rkez szveget szavakra bontjuk...
class Szavakra {
public static void main( String args[] )
FileInputStream fajl = new FileInputStream("vers.txt");
InputStreamReader input = new InputStreamReader(fajl);
// a folyam tagolshoz hasznlt osztly
StreamTokenizer st = new StreamTokenizer(input);
while( st.nextToken() != StreamTokenizer.TT_EOF )
if( st.ttype == StreamTokenizer.TT_WORD )
System.out.println(st.sval);
}
}
10.2.3. Szerializci
Amennyiben objektumokkal szeretnnk folyammveletet vgezni, akor

ehhez az ObjectInputStream s az ObjectOutputStream adatfolyamokat hasznlhatjuk. Ez a kt osztly definilja a readObject() ill. a
writeObject() metdusokat. Ezek segtsgvel az adatfolyambl betlthetnk, illetve kimenthetnk tmb, vagy sztring tpus adatokat, illetve
olyan objektumokat, amelyek megvalstjk a Serializable, vagy az
abbl szrmaztatott Externelizable interfszeket.
A Serializable interfsz egyetlen j metdust sem kvetel meg az
osztly defincijban, csak azt jelezzk, hogy az osztly privt adattagjai
rszt vehetnek az adatfolyam I/O mveleteiben. (Gondoljuk meg, hogy az
Vissza
182
Programozs III.
Vissza
183
objektum rs- olvass jelleg mveletek tulajdonkppen az adatok nyilvnossgra hozatalt jelentik, s az adatrejts alapelve miatt ezt csak gy
nem tehetnnk meg.)
Az Externalizable interfsz megvalstsakor a readExternal(),
s a writeExternal() metdusokat ktelez definilni, amelyben kifejtjk, hogy az adatok elmentse s visszaolvassa hogyan trtnjen.
Egy objektum szerializcijakor nemcsak egy objektum adatait, hanem
az t ler osztly azonostjt is elmentsre kerl, s a beolvasskor ezen
osztlyazonost szerint trtnik a beolvass. Amennyiben az rs s az
olvasa kln modulban van akkor a mentskor hasznlt osztly teljes defincijnak a fogad (beolvas) oldalon is ismertnek kell lennie. A static
s tranzient mdostval elltott adattagokat a szerializci nem menti,
beolvasskor ezek az adattagok alaprtelmezett rtket kapnak.
10.2.4. Kzvetlen elrs llomnyok
Az eddigi adatkezelssel csak a soros (szekvencilis) adatfeldolgozst tettk lehetv. Azaz minden olvass s rsi folyamat csak meghatrozott
sorrendben hajthat vgre.
A tmbk indexelses elrshez hasonlan nha szksgnk van a
forrsfjlok vletlen sorrend elrsre, a fjlon belli pozicionlsra. A
RandomAccessFile osztly segtsgvel ezt is megtehetjk. Az osztly
ltal elrt fjl esetn meghatrozhat a hossz (length), az aktulis fjlmutat (getFilePointer), s szabadon pozicionlhat (seek). Egy fjl
megnyithat csak olvassra r illetve rsra s olvassra rw. A kzvetlen elrs fjlok is tmogatjk a korbban bemutatott adatfolyamok kezelst, de ezzel rszletesen itt nem foglalkozunk.
10.3. Hlzatkezels
A Java hlzati knyvtra (java.net) jelenleg a TCP/IP protokollcsaldra pl, ami a jelenlegi Internet hlzat alapja. Ennek rszleteit csaknem
teljesen elfedi a programoz ell. A kommunikcit egyrszt a TCP
(Transfer Control Protocol) kapcsolatorientlt protokoll, msrszt a
datagrammokra (adatcsomag) pl UDP (User Datagram Protocol) protokoll segtsgvel valstja meg. Ezeken tl tmogatja a HTTP protokoll
kzvetlen hasznlatt, de lehetsget ad egyb kezel eljrsok (protocol
handler) fejlesztsre.
A TCP/IP hlzat szlltsi rtege ktfajta, az n. sszekttets alap
s sszekttets-mentes szolgltatst ismer.
Vissza
183
Programozs III.
Vissza
184
Az sszekttets alap szolgltatst megvalst TCP protokoll tulajdonkppen a kommunikl programok kztt egy ktirny adatfolyamot
valst meg, amelyen az informci bjtsorozatknt ramlik. A kapcsolatorientlt szolgltatst megbzhatnak is nevezik, mert a TCP biztostja a
bjtfolyam torztsmentes, sorrendhelyes tvitelt, kikszblve az elveszett, megsrlt, megduplzdott, vagy ksve rkezett informcicsomagok hatst. Ha pedig semmi nem segt, akkor legalbb a kld, de nha a
vev is rtesl arrl, hogy valami helyrehozhatatlan hiba trtnt.
Az alkalmazsok egy rsznek nincs szksge ekkora megbzhatsgra.
Ekkor berjk az egyszerbben kezelhet UDP protokoll sszekttetsmentes szolgltatsval. Ebben az esetben a knyvtrak s a hlzati architektra mindssze annyit gr, hogy a csomagba sszepakolt bjtokat
(maximlisan 1500 bjt) egyben elkldi a cmzett fel, s mindent megtesz
azrt, hogy az odatalljon, de az elfordul hibk lekezelst nem oldja
meg.
Mivel mindkt esetben konkrt programok kommuniklnak, ezek
egymsra tallshoz a szmtgphez IP cmt ki kell egsztennk a
kommunikcira szolgl kapcsoldsi pontokkal (kapuk, portok). Az
els 1024 port hasznlatt ltalban korltozzk csak rendszergazda
jogosultsg programok olvashatjk a tbbi rendelkezsre ll. A kapuk
egy rsze, az n. jl ismert kapuk (well-known ports) minden szmtgpen szabvnyos funkcikat betlt programokhoz tartoznak.
A Java krnyezet hlzatkezelst tmogat osztlyait a java.net csomagban definiltk, hasznlatukhoz a programok elejn elrhetv kell
tenni az I/O -kezelst megvalst osztlyokkal egytt:
import java.net.*;
import java.io.*;
A hlzati kommunikcihoz a foglalatok (socket) nyjtanak alacsony

szint programozsi interfszt. Az egyes hlzati vgpontok kztti szszekttetst s programok kzti adatcsert socket-tpus folyamokon keresztl oldhatjuk meg. A foglalatokrl rkez adatfolyamokat egyszeren
ms folyamok, szrfolyamok bemenethez kapcsolhatjuk.
Vissza
184
Programozs III.
Vissza
185
27. bra: Kliens-szerver kommunikci felplse

A Java a fenti hlzati protokollokra klnbz tpus socketeket biztost:
sszekttets ala (kapcsolatorientlt) protokoll (Socket)
sszekttetsmentes (kapcsolat nlkli) protokoll (DatagramSocket)
Az albbiakban a teljessg ignye nlkl ltunk nhny pldt az egyes
hlzatkezelsi mveletekre. A tmakr mlyebb elsajttshoz az irodalomjegyzkben felsorolt mveket ajnlom.
10.3.1. sszekttets-alap kommunikci
Az sszekttets-alap kommunikcit a TCP protokoll Socket s

ServerSocket osztlyai valstjk meg, mivel a hlzatos adatforgalomban rszt vev alkalmazsokat mkdsi elvk szerint kt csoportba sorolhatjuk: szerverek s kliensek. A kliensek kapcsolatokat kezdemnyeznek, a szerverek pedig ezeket a krseket kiszolgljk.
A Socket osztly egy-egy pldnya teszi lehetv a kommunikcit
mind a kliens, mind a szerveroldalon. A szerveralkalmazs egyetlen
ServerSocket tpus objektumot hasznl a klnbz kliensekkel val
kapcsolatfelvtelre, de ezt kveten minden egyes klienskapcsolatot mr
kln Socket tpus objektum jelkpez. A kliensek csatlakozsakor ez a
ServerSocket objektum kezeli s szolglja ki a klienseket egy-egy
Vissza
185
Programozs III.
Vissza
186
Socket objektumot rendel az rkez kapcsolati krelemhez illetve
konkurrens krs esetn feldolgozza a vrakozsi sorokat.
28. bra: Az sszekttets-alap kapcsolat kommunikcis iddiagramja

A kliens oldal
A klienseknek kt informcira van szksgk ahhoz, hogy megtalljanak,
s kapcsolatot teremtsenek egy szerveralkalmazssal:
a kiszolgl gp hlzati cmre,
a kiszolgl gp azon portcmre, melyen a szerver a kapcsolatfelvteli krelmeket vrja.
Kapcsolati krelmet a kliensoldalon, az albbi a pldhoz hasonlan tehetjk meg:
try {
Socket s = new Socket("www.sze.hu", 80);
} catch (UnknownHostException e) {
System.out.println("A szerver nem vlaszol!");
}catch (IOException e) {
System.err.println("Sikertelen kapcsolatfelvtel!");
}
Vissza
186
Programozs III.
Vissza
187
Ha egyszer egy kapcsolatot sikerlt felpteni, akkor kinyerhetjk belle a

kommunikcihoz szksges folyamot igaz sokszor csak a folyamok
tbbszrs egymsba gyazsval:
try {
//Kommunikcis vgpont fellltsa
Socket s = new Socket("localhost", 12345);
//Egy kimen folyamot rirnytunk a socketre
OutputStream out = s.getOutputStream();
// A kimen folyamot egy karakteres folyam vghez adjuk
PrintWriter output = new PrintWriter(out);
output.println("Hell n egy kliens vagyok!");
//Adat olvas folyam a kommunikcis vgponton
BufferedReader input = new BufferedReader(
new InputStreamReader(s.getInputStream()));
//Sor(ok) kiolvassa
String st = input.readLine();
...
//Kommuniki lezrsa
s.close();
System.err.println("A szerver nem vlaszol!");
}
A szerver oldal
A szerver alkalmazsok a ServerSocket osztly egy pldnynak accept()
metdust hasznljk arra, hogy a kliensek kapcsolatkrseire vrjanak. Ez
a metdus hozza ltre a klienssel val adatcserhez szksges Socket
tpus objektumot.
Miutn egy kapcsolat felplt, a szerver mr ugyanolyan tpus
Socket objektumokat hasznl, mint a kliensalkalmazs. A ServerSocket
objektum csak a kapcsolat felptshez szksges.
Vissza
187
Programozs III.
Vissza
188
try {
Boolean vege = false;
ServerSocket ss = new ServerSocket(12345);
while (!vege) {
//Felvesszk a kapcsolatot a kvetkez klienssel
//A szerver itt vrakozik egy j kliensre, ha kell
Socket s = ss.accept();
//A kommunikcis vgpontrl adatot olvas folyam
new InputStreamReader(s.getInputStream()));
//A kommunikcis vgpontra adatot r folyam
PrintWriter output = new PrintWriter(
s.getOutputStream(), true); // AutoFlush
//Adatfeldolgozs, adatklds
String st = input.readLine();
System.out.println("Klienstl rkezett: " + st);
output.println("Viszlt, s ksz!");
//Kapcsolat lebontsa
s.close();
if (lellsi felttel) vege =true;
}
//A teljes kommunikci lezrsa
ss.close();
} catch (IOException io) {
System.err.println("Szerver hiba! "+io);
}
10.3.2. sszekttets-mentes kommunikci
Az sszekttets-mentes hlzati kommunikci is a kliens-szerver modell

alapjn pthet fel. A kommunikcis csatornt az UDP protokoll szerinti csomagkapcsolt sszekttets testesti meg. Az adatramlst megbzhatatlannak kell tekintennk.
A megvalstshoz a Java krnyezet a DatagramSocket s a
DatagramPacket osztlyokat nyjtja. A DatagramSocket osztly a
kommunikcis vgpontok folyamkezelst, a DatagramPacket pedig az
elkldend adatcsomagokat kezeli. Ez utbbi tartalmazza a kiindul s a
cllloms cmt is.
Egy
adatcsomag
elkldshez
elszr
egy
adatcsomag
(DatagramPacket) objektumot hozunk ltre, amely tartalmazza:
Vissza
188
Programozs III.
Vissza
189
az elkldend adatot,
az elkldend adat hosszt,
a clszmtgp Internet cmt,
a clszmtgp UDP portjnak azonostjt.
29. bra: Az sszekttets-mentes kommunikci iddiagramja

Az adatcsomag objektumot ezutn tadjuk egy DatagramSocket objektumnak, amelyik ezt a csomagot tjra bocstja a send() metdus segtsgvel.
String szoveg = "Ez itt az tkldend zenet!";
int server_port = 123456;
try {
//Kommunikcis vgpont
DatagramSocket s = new DatagramSocket();
try {
//A szerver cme
InetAddress ip_cim =
InetAddress.getByName("valami.valahol.hu");
//Az zenet hossza s konvertlsa
int uzenet_hossz = szoveg.length();
byte[] uzenet = szoveg.getBytes();
//Az UDP csomag sszelltsa
DatagramPacket p =
new DatagramPacket(uzenet, uzenet_hossz,
ip_cim, server_port);
Vissza
189
Programozs III.
Vissza
190
//Elkldjk a csomagot a kommunikcis vgpontrl

s.send(p);
//Hibakezels
System.err.println("Ismeretlen hoszt!");
} catch (IOException e){
System.err.println("Nem sikerlt a klds!");
} finally {
// megszntetjk a kommunikcis vgpontot
s.close();
}
} catch (SocketException e) {
System.err.println("UDP port foglalsa nem sikerlt!");
}}
Adatcsomag fogadsakor kldshez kpest fordtott utat jrunk be. Egy

DatagramSocket objektummal amely egy adott UDP portot figyel
vrakozunk az rkez csomagra. Az rkez adatok fogadsra ltre kell
hozni egy DatagramPacket objektumot akkora adatterlettel, ahova az
rkez csomag belefr. Ezutn a DatagramSocket objektum receive()
metdusval az els rkez adatcsomagot ha mg nem rkezett semmi,
akkor megvrja visszaadja a DatagramPacket objektumnak.
int server_port = 123456;
try {
//Helyet foglalunk az zenetnek
byte[] uzenet = new byte[1500];
String szoveg;
//A csomag, amely a berkez adatokat fogadja
DatagramPacket p =
new DatagramPacket(uzenet, uzenet.length);
//A szerver kommunikcis vgpontja
DatagramSocket s = new DatagramSocket(server_port);
//vrunk egy csomagot, s a tartalmt beolvassuk p-be
s.receive(p);
//A kapott zenet tartalmt Stringg konvertljuk,
szoveg = new String(uzenet, 0, p.getLength());
// majd kirjuk
System.out.println("Csomag rkezett a " +
p.getAddress().getHostName() + " szmtgptl, a " +
p.getPort() + ". UDP portrl.\n Az zenet: " + szoveg);
Vissza
190
Programozs III.
Vissza
191
//A kommunikcis vgpont lezrsa

s.close();
System.err.println("Ismeretlen hoszt!");
} catch (IOException e) {
System.err.println("Nem sikerlt az adatfogads!");
}
10.3.3. URL-ek hasznlata
Az URL (Uniform Resource Locator) az Interneten elhelyezked erforrsok (brmilyen tpus adatforrst) egysges forrsazonostja. Azonkvl, hogy meghatrozzk egy adattmeg helyt az Interneten, informcit
tartalmaznak az adatok kinyershez hasznlhat protokollrl is. Az URLek tbbnyire szveges adatknt jelennek meg.
protokoll://kiszolgl/hely/objektum
A Java nyelvben az URL-eket az URL osztly egy pldnya reprezentlja.

Egy URL objektum alkalmas valamely URL-lel kapcsolatos sszes informci kezelsre, valamint segtsget nyjt az ltala meghatrozott objektum kinyershez. URL objektum ktflekppen hozhat ltre:
URL honlap = new URL("http://www.sze.hu/index.html" ) ;
URL honlap = new URL("http", "www.sze.hu", "index.html );
Az URL objektum ltrejn fggetlenl attl, hogy az ltala reprezentlt

objektum ltezik-e vagy sem. A ltrehozs sorn az URL objektum nem
teremt hlzati kapcsolatot a kiszolgl gppel.
A ltrehozs alatt a Java elemzi az URL specifikcijt s kiemeli belle a
hasznlni kvnt protokollt, majd megvizsglja, hogy ismeri-e. Abban az
esetben ha nem ismeri MalformedURLException kivtel keletkezik.
Jelentsk meg a kimeneten egy URL-lel azonostott honlap forrst.
import java.net.*;
import java.io.*;
public class URLLista {
public static void main(String [] args) {
try {
URL honlap = new URL("http://szt1.sze.hu/index.html");
//Az URL-lel azonostott erforrs kiolvassa folyammal
new InputStreamReader(honlap.openStream()));
String st;
Vissza
191
Programozs III.
Vissza
192
do {
st = input.readLine();
System.out.println(st);
} while (st != null);
input.close();
} catch(Exception e) {
System.out.println(e);
}}
}
A programban az adott URL-lel azonostott adatot egy pufferezett karakteres folyamknt megnyitjuk, majd soronknt kiratjuk a kimenetre.
10.4. Krdsek
Melyik csomagban talljuk a fjl, s melyikben a hlzatkezelst tmogat osztlyokat?
Mit neveznk adatfolyamnak?
Melyik az a ngy f adatfolyam tpus, amelyet a Java nyelv hasznl?
sszekapcsolhatk-e a Java adatfolyamai? s ha igen, hogyan?
Mit jelent az objektumok szerializcija?
Mi az a socket erforrs?
Mi a klnbsg az sszekttets-alap, s az sszekttets-mentes
kommunikci kztt?
Mi a kliens s a szerver jelleg programok fbb szerepei?
Mi jellemzi az URL osztlyt?
10.5. Feladatok
Egy tetszleges szveges fjlt olvasson be az aktulis knyvtrbl,
majd ksztsen az elfordul karakterekbl betstatisztikt.
Az elz feladat kimenett lltsa el folyam segtsgvel karakteres
fjlban (.txt). Az elll szvegfjl legyen megfelelen tagolt s olvashat.
Egy tetszleges feladatban szerepl osztlyokhoz ksztsen olyan metdusokat, melyek az objektumok adatait egy-egy szvegfjlban troljk.
Egy "matrix.bin" fjlban kb. 500 db long tpus szmot szeretnnk
letrolni. Ksztsen olyan Matrix osztlyt amely ezzel a fjllal tud dolgozni.
Vissza
192
Programozs III.
Vissza
193
a) Ksztse el azt a general(int n) osztlymetdust, amely a fenti

fjlba n db long rtket r ki.
b) Ksztsen olyan Matrix(int n, int m) konstruktort, amely az
inicializls sorn a fenti fjlbl veszi a kedrtkt (ha nincs ilyen fjl,
akkor elszr generljon). Ha a forrsfjlban nincs elegend rtk a
mtrix feltltshez, akkor a tbbi elem nulla kezdrtket kapjon.
Egy klnll tesztprogrambl tesztelje az alkalmazst.
Ksztsen egy osztlyt a XIX. s XX. szzadi idjrsi adatokra (ves
max. kzphmrsklet, ves min. kzphmrsklet, ves tlaghmrsklet, az v legmelegebb, ill. leghidegebb napja stb.) Trolja a tetszleges mdszerrel felvett adatokat szerializci segtsgvel a
idojaras.dat llomnyban. A program legyen kpes kiolvasni, illetve
rni az llomnyt.
Ksztsen a 88-as plyn jtszott torped jtkhoz olyan kliensszerver programot, melyben egy szerverhez egy kliens csatlakozhat. A
hlzati kommunikciban tkldend az adott koordinta, illetve vlaszknt a tallat jelzse. A szerver generljon bizonyos koordintapontokra hajkat, a kliens ezeket a hajkat clozhatja.
Alaktsa t gy a programot, hogy egy szerverhez kt kliens csatlakozhasson, amelyek ekkor egyms ellen jtszhatnak, s a szerver csak kzvett!
Vissza
193
Programozs III.
Fordtsi hibazenetek
Vissza
194
11. Fordtsi hibazenetek

A Java nyelv alapkoncepcija szerint a leggyakoribb programozsi hibknak mr a fordts sorn ki kell derlnie. Ebbl a szempontbl a fordt a
C, C++ nyelvnl szigorbb szintaktikai s szemantikai ellenrzst vgez.
Az albbiakban a fordtsi idben leggyakrabban elfordul hibazenetek
fbb csoportjait tallhatjuk:
Hibazenet
A hiba oka
; missing
Az utasts vgrl hinyz pontosvessz: if, ifelse szerkezeteknl gyakori.

Egy vltozt vagy metdust msodszor is definiltunk.
Ktrtelm osztlyhivatkozs. Amikor kt importlt csomagban van azonos nev osztly.
Egy tmb csak deklarlva lett, de elfelejtettnk
hozz trterletet rendelni a new opertorral.
Egy osztly nem elrhet, valszn nem
publikus.
Absztrakt osztlybl, vagy interfszbl prbltunk pldnyt ltrehozni.
Egy absztrakt osztlyt leszrmaztattunk, vagy
egy interfszt bejelentettnk az osztlyban, de a
benne deklarlt mveletet nem fejtettk ki.
A leszrmazott osztly nem tudja felldefinilni
az s mvelett, ha az final, vagy ha a jogosultsgok nem megfelelek.
Nem tallhat adott nev csomag, osztly, adat,
metdus. Gyakori elrsi hiba.
A klnbz verzij fordtprogramokkal
fordtott kdok esetn lp fel.
Hinyz osztlydefinci, a CLASSPATH krnyezeti vltoz nincs belltva, vagy a csomagelrst elrontottuk.
{} prok szmossgi hibja esetn a fordt nem
already defined
ambiguous class
array not initialised
can't access class
can't be instantiated
does not override
abstract method
cannot override
cannot resolve symbol

class has wrong version
class not found
class or interface
Vissza
194
Programozs III.
Fordtsi hibazenetek
Vissza
expected
duplicate methods,
method already
defined
Exception never
thrown
identifier expected
incompatible type
main must be static
void
method matches
constructor name
method not found
not initialised
possible loss of
precision
undefined variable
unclosed character
literal
unreported exception
unsorted switch
type expected
195
tudja azonostani az osztlyokat, vagy elfelejtettnk osztlyt definilni.

Kt azonos szignatrj metdust prbltunk
definilni.
Az I/O, vagy ms kivteleket nem kezeltnk le a
metdusban.
{} hibk esetn a fordt nem tudja rtelmezni
az azonostkat, vagy azonost nlkli tpust
adtunk meg.
rtkadskor a fordt nem tud automatikusan
konvertlni, explicit konverzi szksges.
Egy futtathat osztlynak rendelkeznie kell a
public static void main (String[]
args) {} metdussal.
Egy osztly konstruktornak nem szabad megadni visszatrsi rtket, az alaprtelmezetten az

osztly tpust kapja.
Hinyz, vagy nem megfelel paramterekkel
hvott metdus.
Loklis vltoz hasznlata kezdrtk ads nlkl.
Automatikus konverzikor rtkveszts trtnhet.
Egy vltozt azeltt hasznlnnk, mieltt deklarltuk volna.
Lezratlan karakterlncok, hinyz aposztrf
jelek: .
Az adott kdrszlet valsznleg kivteleket
vlthat ki. Az utastsokat try-catch blokkba
kell foglalni, vagy a befoglal metdusnak dobnia kell az adott tpus kivtelt (throws).
Kt azonos rtk elgazs egy switch-ben.
Adattagok, loklis vltozk tpus megadsa nlkl.
Vissza
195
Programozs III.
Kdolsi szabvnyok
Vissza
196
12. Kdolsi szabvnyok

A felmrsek szerint a szoftverek fejlesztsi idejnek 80%-a karbantartssal s a programok elemzsvel telik. Napjainkban a szoftvereket ritkn
kszti el egyetlen szemly, gy az tlthatsgra s az egyrtelm rtelmezhetsgre oda kell figyelni. Amennyiben valaki valamely munka forrsait kzzteszi, annak jl felptettnek s tlthatnak kell lennie.
A kdolsi elrsok/megllapodsok nagyban elsegtik a forrsok tlthatsgt, s lehetv teszik a programozknak egy ismeretlen kd
gyors s mlyrehat rtelmezst. A tiszta kdols segt elkerlni a szemantikai szempontbl ered hibkat.
Az albbiakban az eredeti kdolsi szabvnyok magyar fordtst kzljk, amelynek eredetije az Interneten elrhet [6].
Megjegyezzk, hogy a fejezetben szerepl szablyok nagyrszt csak
ajnlsok, amelyek a forrsok egysges rtelmezst segtik, amitl a forrsok olvashatk s ttekinthetbb vlnak.
12.1. Fjlnevek
Egy Java nyelv forrs fjlnak .java kiterjesztssel kell rendelkeznie, mg
a lefordtott bjtkd a .class kiterjesztst kapja.
12.1.1. ltalnosan hasznlt nevek
ltalnosan hasznlt neveket hasznljunk makefile esetn (GNUmakefile),

ha a gnumake alkalmazst hasznljuk az alkalmazs fordtsra, s az adott
knyvtr tartamnak szveges lerst tartalmaz fjl esetn (README).
12.2. Fjlok felptse
Egy fjl szakaszokbl ll, melyeket res sorokkal kell elvlasztani, illetve
ajnlott megjegyzseket tenni, azonostskppen. A 2000 programsornl
hosszabb fjlokat lehetleg kerljk. A dokumentum vgn tallhat egy
plda a megfelelen formzott Java forrsfjlra.
12.2.1. Java forrsfjlok
Minden Java forrsfjl tartalmaz egy publikus osztlyt vagy interfszt. Ha

ehhez tartoznak privt osztlyok vagy interfszek, akkor azokat nyugodtan
Vissza
196
Programozs III.
Kdolsi szabvnyok
Vissza
197
elhelyezhetjk ebben a fjlban. A publikus osztlynak vagy interfsznek

kell az elsnek lennie a forrsban.
A Java forrsnak kvetnie kell a kvetkez sorrendet:
Kezd megjegyzsek.
Csomag- illetve importdeklarcik.
Osztly- s interfszdeklarcik.
12.2.2. Kezd megjegyzsek.
Minden forrs elejn egy C-stlus megjegyzsnek kell lennie, amely tartalmazza az osztly nevt, verzival kapcsolatos informcikat, dtumot s
copyright megjegyzseket:
/*
* Osztlynv
*
* Verzival kapcsolatos informcik
*
* Dtum
*
* Copyright megjegyzsek
*/
12.2.3. Csomag- s import deklarcik
Az els sor a Java forrsban, mely nem megjegyzs, az a csomagdeklarci. Ezutn az importdeklarcik kvetkezhetnek. Pldul:
package java.awt;
import java.awt.peer.CanvasPeer;
Az egyedi csomag azonost els tagja mindig kisbetkbl lljon, s toplevel domain azonost legyen, azaz com, edu, gov, mil, net, org vagy a
ktbets orszg azonost, melyeket az ISO Standard 3166, 1981definil.
A Java API-ban definilt csomagok is bejelenthetk, de megjegyezzk,
hogy a java, javax s sun azonostk a Sun Microsystems szmra fenntartottak.
12.2.4. Osztly s interfsz deklarcik
A kvetkez tblzat lerja az osztly- vagy interfszdeklarci elemeit

olyan sorrendben, ahogy a forrsban szerepelnik kell.
1. Osztly/interfsz
dokumentcis megjegyzs
(/** */)
Vissza
197
Programozs III.
Kdolsi szabvnyok
Vissza
198
2. Osztly/interfsz fejrsze.
3. Osztly/interfsz implementcis megjegyzsek, ha szksgesek. Ez a
megjegyzs tartalmazhat osztly vagy interfsz szint kiegszt informcikat, melyek nem kerltek be a dokumentcis megjegyzsbe.
4. Osztlyvltozk. Elszr a nyilvnos, majd a vdett (protected), majd
a flnyilvnos tagok, vgl a privt tagok.
5. Pldnyvltozk. Kvetve az elbbi sorrendet.
6. Konstruktorok
7. Metdusok. Ezeket a metdusokat inkbb a mkds alapjn kell csoportostani, mint a hozzfrhetsg vagy lthatsg alapjn. Pldul
egy privt metdus szerepelhet kt publikus metdus kztt. A cl,
hogy a kd olvassa s megrtse egyszerbb legyen.
12.2.5. Behzs
A behzs alapegysge ngy szkz karakter. A ngy szkz elhelyezsnek pontos mdja nincs specifiklva (lehet hasznlni szkzt vagy tab-ot
is). A tab-nak pontosan nyolc szkzbl kell llnia, nem ngybl.
Sorhossz
A 80 karakternl hosszabb sorok kerledk, mivel tbb terminl s fejleszteszkz nem tudja megfelelen kezelni.
Megjegyzs: A pldk a dokumentcikban ltalban rvidebbek, a sorhosszak nem nagyobbak, mint 70 karakter.
Sortrsek
Ha egy kifejezs nem fr el egy sorban, akkor a sortrst a kvetkez
alapelvek szerint kell vgezni:
Sortrs egy vessz utn.

Sortrs egy opertor eltt.
Magas szint trsek preferlsa az alacsonyszintekkel szemben.
Az j sor elhelyezse az elz sorban lv azonos szint kifejezs kezdethez igaztva.
Ha a fenti szablyok a kd sszezavarshoz vezetnnek, vagy a kd a
jobb margnl srsdne, akkor hasznljunk nyolc szkzt a tbbszrs behzs helyett.
Vissza
198
Programozs III.
Kdolsi szabvnyok
Vissza
199
lljon itt kt plda a metdushvsokon belli sortrsekre:

someMethod(longExpression1, longExpression2,
longExpression3,longExpression4, longExpression5);
var = someMethod1(longExpression1,
someMethod2(longExpression2,
longExpression3));
A kvetkez kt plda az aritmetikai kifejezseken belli sortrsekre hoz

pldt. Az els az ajnlott, mivel a sortrs a magasabb helyen lv zrjelezett kifejezsen kvl van.
longName1 = longName2 * (longName3 + longName4 - longName5)
+ 4 * longName6; // Ajnlott
longName1 = longName2 * (longName3 + longName4
- longName5) + 4 * longName6; // Elkerlend
Kvetkezik kt plda a metdusdeklarci behzsra. Az els a hagyomnyos eset. A msodik esetben a msodik s a harmadik sort nyolc szkzzel hztuk be, ugyanis a sorok a jobb oldalon srsdnnek a konvencionlis megolds hasznlata esetn.
// Konvencionlis behzs
someMethod(int anArg, Object anotherArg,
String yetAnotherArg,Object andStilAnother) {
...
}
// Tbbszint behzs esetn nyolc szkz hasznlata
private static synchronized horkingLongMethodName(
int anArg,
Object anotherArg,
String yetAnotherArg,
Object andStilAnother) {
...
}
Sortrsnl if kifejezs esetn a nyolc szkzs szablyt alkalmazzuk, ha a

konvencionlis (4 szkzs) szably a trzset tl bonyolultt tenn. Plda:
Vissza
199
Programozs III.
Kdolsi szabvnyok
Vissza
200
//Ne hasznljuk ezt a behzst

if ((condition1 && condition2)
|| (condition3 && condition4)
|| (condition5 && condition6)) { //A rossz sortrsek miatt
doSomethingAboutIt(); //ez a sor knnyen
} //eltveszthet
//Helyette hasznljuk ezt
if ((condition1 && condition2)
|| (condition3 && condition4)
|| (condition5 && condition6)) {
doSomethingAboutIt();
}
//Vagy ezt
if ((condition1 && condition2) || (condition3 && condition4)
|| (condition5 && condition6)) {
doSomethingAboutIt();
}
Pldk a feltteles kifejezs hasznlatra:

alpha = (aLongBooleanExpression) ? beta : gamma;
alpha = (aLongBooleanExpression) ? beta
: gamma;
alpha = (aLongBooleanExpression)
? beta
: gamma;
12.3. Megjegyzsek
A Java programokban ktfajta megjegyzsek lehetnek: implementcis s
dokumentcis megjegyzsek. Az implementcis megjegyzsek vannak
C++ nyelv forrsszvegben is, melyeket a /* */, vagy a // szimblumok jellnek. A dokumentcis megjegyzsek csak Java nyelvben lteznek,
ezeket a /** */ zrjelprokkal kell jellni. A javadoc programmal ezek
a megjegyzsek bekerlnek egy HTML fjlba sok egyb informcival
egytt. Az implementcis megjegyzsekkel a forrskd szvege magyarzhat. A dokumentcis megjegyzsek ezzel szemben a specifikcit
magyarzzk, mellzve az implementcis krdseket, s azokhoz a fejlesztkhz szlnak, melyeknek nincs szksgk az adott rsz forrskdjra.
A megjegyzsek szksg esetn nyjtsanak ttekintst, illetve olyan
plusz informcikat tartalmazzanak, amelyek nem szembetnk a kd
egyszeri elolvassakor. A megjegyzseknek csak olyan informcikat kell
tartalmaznia, melyek segtik a program olvashatsgt, illetve megrtst.
Vissza
200
Programozs III.
Kdolsi szabvnyok
Vissza
201
Nem trivilis tervezi dntsek magyarzata odaill, viszont kerlni

kell az olyan informcik ismtlst, melyek adottak (s vilgosak) a kdban. A redundns adatok mdostsa tbbletmunkt eredmnyez. A megjegyzsek nnyen elvlhetnek, ezrt kerlni kell minden olyan megjegyzst, mely a program vltozsa sorn rvnyt vesztheti.
Megjegyzs: A megjegyzsek arnytalanul nagy mennyisge takargathatja a
kd gyenge minsgt. Ezrt j megjegyzs beszrsa helyett rdemes
elgondolkozni a kd rthetbb tteln. A megjegyzseket nem szabad
krlrajzolni karakterekkel. A megjegyzsekben kerljk a specilis karaktereket hasznlni.
12.3.1. Implementcis megjegyzsek formtumai
Az implementcis megjegyzseknek ngy alakja lehet: blokk, egysoros,

ut- s sorvgi megjegyzsek.
Blokk megjegyzsek
A blokk megjegyzsek hasznlhatak fjlok, metdusok, adatstruktrk s
algoritmusok lersra. Ezen kvl mshol is elhelyezkedhetnek, pldul
metdusokon bell. A blokk megjegyzseknek egy metduson bell azonos szinten kell lennie a kddal, amelyet magyarz.
A blokk megjegyzsnek egy res sorral kell kezddnie, mely elvlasztja
a megjegyzst a kdtl.
/*
* Ez egy blokk megjegyzs.
*/
A blokk megjegyzsek /*- szimblumsorozattal kezddnek, mely jelzi a

behzst vgz programnak (indent), hogy a megjegyzst nem lehet tformzni.
/* * Ez egy blokk megjegyzs specilis formtumozssal,
* melynl az jraformzs kerlend.
*
* egy
* kett
* hrom
*/
Vissza
201
Programozs III.
Kdolsi szabvnyok
Vissza
202
Megjegyzs: Ha nem hasznljuk az behzst vgz programot, akkor

nem kell alkalmazni a /*- karaktersorozatot, de rdemes, abban az esetben, ha ms akarja hasznlni a mi kdunkon.
Egysoros megjegyzsek
Rvid megjegyzsek egy sorban alkalmazhatk, azon a szinten, melyen az
elz sor is van. Ha a megjegyzs nem rhat egy sorba, akkor a blokk
megjegyzst kell alkalmazni. Az egysoros megjegyzs eltt egy res sornak
kell llnia. Plda:
if (feltetel) {
/* Ha a felttel teljesl. */
...
}
Utmegjegyzsek
Nagyon rvid megjegyzsek kerlhetnek egy sorba a kdrszlettel, melyet
magyarznak, viszont megfelel tvolsgra kell attl tenni. Ha tbb mint
egy megjegyzs tartozik egy kteg programsorhoz, akkor azokat ugyanolyan tvolsgra kell tenni.
if (a == 2) {
return TRUE;
} else {
return isPrime(a);
}
/* specilis eset */
/* csak pratlan szmok esetn */
Sorvgi megjegyzsek
A // karakterekkel megjegyzsbe lehet tenni egy teljes sort, illetve egy sor
vgt. Nem szabad hasznlni tbbsoros megjegyzsekhez, abban az esetben viszont lehet, ha a forrskdbl tbb egyms utni sort akarunk megjegyzsbe tenni.
Plda a hrom hasznlati mdra:
if (foo > 1) {
// Dupla dobs.
...
}
else {
return false; // Mirt itt?
}
Vissza
202
Programozs III.
Kdolsi szabvnyok
Vissza
203
//if (foo > 1) {

//
//
// Dupla dobs.
// ...
//}
//else {
// return false;
//}
Dokumentcis megjegyzsek
A dokumentcis megjegyzsek jellemzik a Java osztlyokat, interfszeket,
konstruktorokat, metdusokat s adattagokat [14]. Minden dokumentcis
megjegyzst a /** s */ karaktersorozatok hatrolnak, osztlyonknt,
interfszenknt s tagonknt egyszer. Ennek a megjegyzsnek a deklarci
eltt kell szerepelnie:
/**
* Az Example osztly ...
*/
public class Example { ...
Megjegyezzk, hogy a legfels szint osztlyok s interfszek nincsenek

behzva, mg azok tagjai igen. Az osztlyokhoz s interfszekhez tartoz
dokumentcis megjegyzsek els sora (/**) nincs behzva, a kvetkez
sorok be vannak hzva egy karakterrel (hogy a csillagok egyms al essenek). A tagoknl, belertve a konstruktort is, a behzs az els sorban
ngykarakternyi, mg t a rkvetkezkben. Ha tbb informcit kell
megadni az osztlyhoz, interfszhez, vltozhoz vagy metdushoz, de
nem akarjuk, hogy a dokumentciban megjelenjen, implementcis blokkot, vagy egysoros megjegyzst kell hasznlni azonnal a deklarci utn.
Dokumentcis megjegyzseket nem lehet egy metduson vagy
konstruktoron bell hagyni, ugyanis a Java a megjegyzs utni els deklarcira vonatkoztatja a megjegyzst.
12.4. Deklarcik
Deklarcik soronknti szma
Soronknt egy deklarci ajnlott, a megjegyzsek miatt is. Azaz
int level; // szint
int size; // tbla mrete
ajnlott az
Vissza
203
Programozs III.
Kdolsi szabvnyok
Vissza
204
int level,size;
helyett.
Egy sorba semmikppen ne tegynk klnbz tpus deklarcikat.
Pldul:
int foo, fooarray[]; //HIBS!
Megjegyzs: A fenti pldk egy szkz helyet hagytak a tpus s a nv

kztt. Msik elfogadhat vlasztsi lehetsg a tabok hasznlata, azaz:
int
level; // szint
int
size; // tbla merete
Object currentEntry; // kivlasztott tblabejegyzs
Inicializls
rdemes a loklis vltozkat ott inicializlni, ahol deklarlva lettek. Az
egyetlen eset, amikor ez nem hasznlhat, ha a kezdrtk valamilyen
szmts eredmnye.
Elhelyezs
A deklarcikat lehetleg a blokk elejre tegyk. Blokk a kapcsos zrjelek
{ } ltal hatrolt rsz. Ne vrjunk a deklarcival addig, mg a vltozt
elszr hasznlatba vesszk.
void myMethod() {
int int1 = 0;
if (condition) {
int int2 = 0;
...
}
}
// metdus trzsnek kezdete

// if trzsnek kezdete
A szably alli kivtel a for ciklus fejben deklarlt vltoz:

for (int i = 0; i < maxLoops, i++) { ... }
Azon deklarcik, melyek egy magasabb szinten deklarlt nevet elfednek,

kerlendk! Pldul nem ajnlott ugyanolyan nvvel egy msik vltozt
deklarlni:
Vissza
204
Programozs III.
Kdolsi szabvnyok
Vissza
205
int count;
...
myMethod() {
if (condition) {
int count; // KERLEND!
...
}
...
}
12.4.1. Osztly s interfsz deklarcik
Java osztlyok s interfszek deklarcijnl a kvetkez szablyokra kell

gyelni:
Nincs szkz a metdus nv s a formlis paramterlistt kezd nyit
zrjel kztt.
A metdus fejvel egy sorban kell a nyit kapcsos zrjelnek (``{``)
lennie.
A metdusokat res sorral kell egymstl elvlasztani.
A zr kapcsos zrjelnek } egymagban kell a sorban llnia, egy oszlopban a fej els karaktervel, kivve, mikor a metdus trzse res,
ekkor egybl a nyit zrjel utn kell llnia.
class Sample extends Object {
int ivar1;
int ivar2;
Sample(int i, int j) {
ivar1 = i;
ivar2 = j;
}
int emptyMethod() {}
...
}
12.4.2. Utastsok
Egyszer utastsok
Minden sornak csak egy utastst szabad tartalmaznia, pldul:
argv++; // Helyes
argc++; // Helyes
argv++; argcc++; // KERLEND!
Vissza
205
Programozs III.
Kdolsi szabvnyok
Vissza
206
sszetett utastsok
Az sszetett utastsok olyan utastsok listja, melyek kapcsos zrjelek
kztt vannak: { utastsok }.
A kapcsos zrjelek kztti utastsokat egy szinttel beljebb kell hzni.
A nyit zrjelnek azon sor vgn kell szerepelnie, mely megkezdi az
sszetett utastst; a csuk zrjelnek sor elejn kell szerepelnie, annyival behzva, mint a kezd utasts.
Zrjeleket akkor is hasznlni kell, ha egy vezrlsi szerkezet trzseknt csak egy utastst szeretnnk szerepeltetni. Ez megknnyti a
trzs bvtst, anlkl, hogy valami hibt vtennk a zrjelek elhagysa miatt.
A return utasts
A return utastsnl nem szksges hasznlni a zrjeleket, ha a visszatrsi rtk gy is nyilvnval. Pldk:
return;
return myDisk.size();
returt (size ? size : defaultSize);
Az if, if-else, if else-if else utastsok

Az if-else szerkezeteket a kvetkez alakban kell hasznlni:
if (feltetel) {
utasitasok;
}
if (feltetel) {
utasitasok;
} else {
utasitasok;
}
if (feltetel) {
utasitasok;
} else if (feltetel) {
utasitasok;
} else {
utasitasok;
}
Vissza
206
Programozs III.
Kdolsi szabvnyok
Vissza
207
Megjegyzs: Az if szerkezeteknl is mindig ajnlott a blokkzrjelek

hasznlata akkor is, ha az g csak egyetlen utastst tartalmaz. Kerlend a
kvetkez forma:
if (feltetel) // KERLEND! HINYZ BLOKKZRJELEK!
utasitas;
A for utasts
A for utastsnl a kvetkez formt ajnlott kvetni:
for (inicializalas; feltetel; leptetes) {
utasitasok;
}
Egy res trzzsel rendelkez for utastsnak a kvetkezkppen kell kinznie:

for (inicializalas; feltetel; leptetes);
Az inicializls vagy lptets sorn hasznlhatunk vessz opertort, azaz

tbb vltozt is deklarlunk, de kerlend a hromnl tbb vltoz hasznlata. Ha szksges, akkor ezt tegyk meg a for ciklus eltt, vagy a ciklus
trzsnek vgn.
A while utasts
A while utasts hasznlata a kvetkez formban ajnlott:
while (feltetel) {
utasitasok;
}
Az res while utasts alakja:

while (feltetel);
A do-while utasts
Formja:
do {
utasitasok;
} while (feltetel);
Vissza
207
Programozs III.
Kdolsi szabvnyok
Vissza
208
A switch utasts
A switch utastst a kvetkez alakban kell hasznlni:
switch (feltetel) {
case ABC:
utasitasok;
/* tovbblp */
case DEF:
utasitasok;
break;
case XYZ:
utasitasok;
break;
default:
utasitasok;
break;
}
Minden esetben, ha a vezrls a kvetkez eseten folytatdik (azaz hinyzik a break utasts), hasznlni kell egy megjegyzst a break helyn. Jelen
esetben a /*tovbblp */ megjegyzst hasznltuk.
A try-catch utasts
A try-catch utastst a kvetkez alakban hasznljuk:
try {
utasitasok;
} catch (ExceptionClass e) {
utasitasok;
}
A try-catch utastst kvetheti finally utasts, a vezrls mindenkpp

eljut erre az gra, fggetlenl attl, hogy a try, vagy a catch blokk sikeresen vgrehajtdott-e, vagy sem. Hasznlata:
try {
utasitasok;
} catch (ExceptionClass e) {
utasitasok;
} finally {
utasitasok;
}
Vissza
208
Programozs III.
Kdolsi szabvnyok
Vissza
209
12.4.3. Fehr karakterek (whitespace)
res sorok
Az res sorokkal a logikailag sszetartoz kdrszeket emelhetjk ki, ami
nveli az olvashatsgot.
Kt res sort hasznlunk a kvetkez esetekben:
a forrs fjl kt bekezdse kztt;
osztly- s interfszdefincik kztt.
Egy res sort hasznlunk a kvetkez esetekben:
metdusok kztt;
egy adott metdus loklis vltozi s az els utasts kztt;
blokk vagy egysoros megjegyzs eltt;
az egy metduson belli logikai szakaszok kztt az olvashatsg nvelse rdekben.
Szkzk
Szkzket kell hasznlni a kvetkez esetekben:
Ha egy kulcsszt kerek zrjel kveti, akkor el kell vlasztani ket egy
szkzzel.
while (true) {
...
}
Megjegyzend, hogy szkz nem hasznlhat a metdus neve s nyit

kerek zrjele kzt. Ez segt elklnteni a kulcsszavakat a metdushvsoktl.
Az argumentum-listban szkznek kell kvetnie minden vesszt.
Minden ktoperandus opertort, a . kivtelvel elvlasztunk egy szkzzel az operandusaitl. Tilos szkzt hasznlni az unris opertor s
operandusa kztt, mint pldul az eljelvlts (-), a nvel (++) s a
cskkent (--) opertorok esetn. Pldk:
Vissza
209
Programozs III.
Kdolsi szabvnyok
Vissza
210
a += c + d;
a = (a + b) / (c * d);
while (d++ = s++) {
n++;
}
printSize("size is " + foo + "\n");
A kifejezseket egy for utastsban el kell vlasztani szkzkkel. Plda:

for (expr1; expr2; expr3)
A tpusknyszertseket szkznek kell kvetnie. Pldul:

myMethod((byte) aNum, (Object) x);
myMethod((int) (cp + 5), ((int) (i + 3)) + 1);
12.5. Elnevezsi konvencik

Az elnevezsi konvencik knnyebben olvashatv s gy jobban rthetbb teszik a forrskdot. A jl megvlasztott azonostk informcikat
adhatnak az azonost funkcijrl, ami javtja a kd rthetsgt.
12.5.1. Azonost tpus
Csomagok
Az egyedi csomagnevek prefixt mindig kis ASCII karakterekkel kell rni
s a top-level domain nevek egyiknek kell lennie. Jelenleg lehet com, edu,
gov, mil, net, org vagy az orszgok angol ktbets azonostkdjnak
egyike, melyeket az ISO 3166 s 1981 szabvnyok definilnak.
A csomag nevnek tbbi komponenst a szervezet sajt bels elnevezsi
konvenciinak megfelelen vltoztathatjuk. Pldul a csomagnevek tartalmazhatnak divzi, osztly, hivatal, projekt, gp s felhasznl neveket.
com.sun.eng
com.apple.quicktime.v2
edu.cmu.cs.bovik.cheese
Osztlyok
Az osztlyneveknek fneveknek kell lennik s minden bels sz els
betjt nagybetvel kell rni. Trekedni kell, hogy az osztlynevek egyszerek s kifejezek legyenek. Kerlendek a rvidtsek, kivve nagyon
nyilvnval esetben, mint az URL vagy HTTP.
class Raster;
class ImageSprite;
Vissza
210
Programozs III.
Kdolsi szabvnyok
Vissza
211
Interfszek
Az interfsznevekben a fneveket az osztlynevekhez hasonlan nagybetvel kell kezdeni.
interface RasterDelegate;
interface Storing;
Metdusok
A metdus neveknek kisbetvel kezdd igknek kell lennie, de a bels
szavakat nagybetvel kell kezdeni.
run();
runFast();
getBackground();
Vltozk
A for vltozkat kivve minden pldny-, osztly- s osztlyhoz tartoz
konstans kezdbetjnek kisbetnek kell lennie, a bels szavak nagybetvel kezddjenek. Pldul az
int i;
char c;
float myWidth;
vltoz nevek nem kezddhetnek alhzs (_) vagy dollrjellel ($), habr
mindkett szintaktikailag megengedett.
A vltoznevek lehetleg rvidek s kifejezek legyenek. A vltoznv
megvlasztsakor gyeljnk arra, hogy a nv tkrzze a vltozk hasznlatnak szerept. Az egy-karakteres vltoz neveket kerljk kivve az ideiglenes, eldobhat vltozkat. Az ideiglenes vltozknak ltalnos nevei
pldul az i, j, k, m s n az egsz tpusak; c, d s e a karakter tpusak
szmra.
Konstansok
Az osztlyszint konstansoknak deklarlt vltozkat s a konstansokat
csupa ANSI nagybetvel kell rni s a szavakat alhzs jellel (_) kell elvlasztani.
static final int MIN_WIDTH = 4;
static final int MAX_WIDTH = 999;
static final int GET_THE_CPU = 1;
Vissza
211
Programozs III.
Kdolsi szabvnyok
Vissza
212
12.6. Programozsi tancsok

12.6.1. Pldny vagy osztlyvltozhoz val hozzfrs
szablyozsa
Egyetlen pldny vagy osztlyvltozt se tegynk ok nlkl publikuss.

Gyakran a pldnyvltoznak nem szksges explicit rtket adni, mert ez
egy metdus hvs mellkhatsaknt fog bekvetkezni.
A publikus pldnyvltoz indokolt hasznlatra plda az olyan osztly, ami valjban csak adatstruktra s nem trolja az adatok viselkedst. Ms szavakkal ha struct deklarcit hasznlnnk (ha ltezne a Java
nyelvben) osztlydeklarci helyett.
Hivatkozs osztlyvltozkra s metdusokra
Kerljk az objektumok hasznlatt statikus vltoz vagy metdus elrshez. Ilyenkor csak az osztlynv hasznlata a megengedett. Pldk:
classMethod(); //OK
AClass.classMethod(); //OK
anObject.classMethod(); // KERLEND!
Konstansok
Numerikus konstansokat nem szabad kzvetlenl a kdban szerepeltetni a
-1, 0 s 1 kivtelvel, melyek pldul a for ciklus fejbn szerepelhetnek.
rtkads
Kerlend tbb vltoznak az egy utastsban val rtkads, mert nehezen olvashat. Pldul:
fooBar.fChar = barFoo.lchar = 'c'; // KERLEND!
Ne hasznljuk az rtkads opertort olyan helyeken, ahol knnyen sszetveszthet az sszehasonlt opertorral. Plda:
if (c++ = d++) { //HIBS!
...
}
Helyette gy hasznlhatjuk:
if ((c++ = d++) != 0) {
...
}
Ne hasznljunk egymsba gyazott rtkadsokat a futsid cskkentsre. Ez a fordt dolga. Plda:

d = (a = b + c) + r; // KERLEND!
Vissza
212
Programozs III.
Kdolsi szabvnyok
Vissza
213
Helyette:
a = b + c;
d = a + r;
Zrjelek
ltalban vve j programozi gyakorlat a zrjelek b alkalmazsa a kifejezsekben, hogy elkerljk a precedencia problmkat. gy azok szmra
is egyrtelm lesz, akik nem ltjk t elsre a kifejezst vagy nincsenek
tisztban az opertorok precedencijval.
if (a == b && c == d) // KERLEND!
if ((a == b) && (c == d)) // Helyes
Visszatrsi rtkek
Prbljuk a program struktrjt gy kialaktani, hogy tkrzze a szndkot. Pldul az albbi sorok helyett:
if (booleanExpression) {
return true;
} else {
return false;
}
Ez az egyszerbb kifejezs lljon:

return booleanExpression;
Hasonlan az elzhz:
if (condition) {
return x;
}
return y;
Helyette:
return (condition ? x : y);
Kifejezs a "?" eltt a feltteles opertorban

Ha egy kifejezs binris opertort tartalmaz a ? eltt egy hromoperandus ? : opertorban, akkor zrjelezni kell. Plda:
(x >= 0) ? x : -x;
Vissza
213
Programozs III.
Kdolsi szabvnyok
Vissza
214
Specilis megjegyzsek
Hasznljuk az XXX szt a megjegyzsben annak jelzsre, ha valami mg
hibs, de mkdik. Hasznljuk a FIXME, vagy a TODO szt pedig annak a
jellsre, hogy valami hibs s nem mkdik jl.
12.7. Kd pldk
Java forrsfjl pldk
A kvetkez plda bemutatja hogyan formzzuk az egyszer publikus
osztlyt tartalmaz Java forrs fjlt. Az interfszeket hasonlan kell formzni.
/*
* @(#)Blah.java 1.82 99/03/18
*
* Copyright (c) 1994-1999 Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
* All rights reserved.
*
* This software is the confidential and proprietary
* information of Sun Microsystems, Inc. ("Confidential
* Information"). You shall not disclose such Confidential
* Information and shall use it only in accordance with the
* terms of the license agreement you entered into with Sun.
*/
package java.blah;
import java.blah.blahdy.BlahBlah;
/**
* Az osztly lersa ide jn.
*
* @version 1.82 18 Mar 1999
* @author Firstname Lastname
*/
public class Blah extends SomeClass {
/* Itt kvetkezhetnek az osztly implementcis megjegyzsei
*/
/** classVar1 dokumentcis megjegyzs */
public static int classVar1;
/**
* classVar2 dokumentcis megjegyzs,
* egy sornl hosszabb eset
*/
Vissza
214
Programozs III.
Kdolsi szabvnyok
Vissza
215
215
private static Object classVar2;

/** instanceVar1 dokumentcis megjegyzs */
public Object instanceVar1;
protected int instanceVar2;
private Object[] instanceVar3;
/**
* ...constructor Blah dokumentcis megjegyzs...
*/
public Blah() {
// ...Itt jn az implementci...
}
/**
* ...method doSomething dokumentcis megjegyzs...
*/
public void doSomething() {
}
/**
* ...method doSomethingElse dokumentcis megjegyzs...
* @param someParam lers
*/
public void doSomethingElse(Object someParam) {
}
}
Vissza
Programozs III.
Mellkletek
Vissza
216
13. Mellkletek
Az albbiakban a jegyzet f fejezeteibe be nem sorolhat, illetve nhny
gyakran felmerl krdst tisztz fejezetet tallunk. A jegyzetben tallhat pldaprogramokat terjedelmi okokbl nem kzljk, de a forrskdok
a http://szt1.sze.hu/java/ cmrl szabadon letlthetek.
13.1. A Java keretrendszer teleptse s a
krnyezet belltsa
Ahhoz, hogy Java programokat fejleszthessnk, be kell szereznnk a Java
forrsokat (legegyszerbben a http://java.sun.com/j2se cmrl).
Elszr a Java fejlesztshez alkalmas szoftvert kell telepteni. Mivel a
rvidtsek kztt gyakori a kevereds, fontos a JRE s a JDK megklnbztetse:
JRE (Java Runtime Environment) ~10Mb /, tartalmazza a java alkalmazsokhoz hasznlhat erforrsokat, mint pl: Java Virtulis
Gp (JVM), a szabvnyos osztlyknyvtrak (class library), Java alkalmazsindt stb. Azonban ez mg nem tartalmaz fordtt, hibakerest, s fejleszt krnyezetet sem, gy a fejlesztsekhez nem alkalmas
JDK (Java Development Kit) ~40Mb 60Mb, a java fejlesztsekhez hasznlatos krnyezet. Tbb parancssori eszkzt tartalmaz
(javac, javadoc, appletviewer, HtmlConverter, jar fjlcsomagol
stb.). Tartalmazza a JRE-t is.
JDK + NetBeans ~120Mb 130 Mb, Java fejlesztkrnyezet,
amely mr a NetBeans integrlt fejlesztkrnyezetet is tartalmazza.
Msodszor be kell lltani a megfelel elrsi utakat s krnyezeti vltozkat. A PATH bejegyzsben fel kell venni a teleptett JDK bin knyvtrt.
(pl: c:\jdk1.5.0\bin\). Ugyanitt ltre kell hozni egy CLASSPATH nev s . ; c:\munkakvt rtk krnyezeti vltozt.
Linux opercis rendszeren a kvetkez mdon:
export PATH=$SPATH:/opt/java/bin: .
export CLASSPATH=$CLASSPATH:/home/munka: .
Windows opercis rendszeren parancssorbl, vagy bat llomnybl:

SET PATH=%PATH%;c:\Program Files\java\jdk1.5.0\bin\ ; .
SET CLASSPATH=%CLASSPATH%;c:\munka\ ; .
Vissza
216
Programozs III.
Mellkletek
Vissza
217
Windows opercis rendszer esetn a Sajtgp / Tulajdonsgok

/ Specilis / Krnyezeti vltozk menpont alatt jegyezhetjk be a vltoztatsokat.
30. bra: Krnyezeti vltozk belltsa

Amennyiben a krnyezeti vltozk belltsa sikerlt, egy konzol ablakban
(cmd.exe) a java, ill. javac parancsok futtathatak s brmilyen knyvtrbl elrhetek! (Ellenrzshez gpeljk be a javac illetve a java parancsokat paramterek nlkl. Amennyiben mindkt parancs egy kb. egy
kpernyoldalas zenetet kld a helyes hasznlatrl, akkor a krnyezeti
vltozk belltsa sikerlt!)
Ezutn telepthetnk egyes fejleszt programokat:
WsCite:
Egy nagyon kis helyigny, egyszer fejleszteszkz (IDE), melynek szvegszerkesztje nagyon felhasznlbart, nyelvi szintakszis
kiemelsi, fordtsi s futtatsi lehetsggel. (Freeware.)
JCreator Light Edition:
Egy ingyenes s hasznos IDE eszkz. Aki jratos a Visual C++ keretrendszerben annak knnyen eligazodhat projectek s csomagok
ksztshez, fordtshoz.
Vissza
217
Programozs III.
Mellkletek
Vissza
218
A NetBeans s Java Studio:

A Sun Microsystems, illetve a Netbeans sajt IDE rendszere. Elssorban grafikus s kliens-szerver alkalmazsok fejlesztsre. Rengeteg kiegsztt integrltak benne, melyekkel professzionlis s hatkony alkalmazsokat lehet fejleszteni. (Freeware.)
Eclipse:
Az Eclipse (IBM) egy nagyon elterjedt, csomagalap fejleszteszkze. (Freeware.)
JBuider:
A Borland Co. termke. Hasonlan sszetett eszkz, nagy projektek , grafikus fellet (awt, swing) alkalmazsok hatkony fejlesztshez hasznlhat. Fleg a Delphit ismer programozk kztt
terjedt el.
stb
A grafikus keretrendszerek tgondolt s ksz krnyezetet nyjtanak, m az
elkszlt programok keretrendszer nlkl is parancssorbl fordthatak, illetve teleptett JVM esetn futtathatak.
13.2. Dokumentcis segdprogramok
A tiszta s tlthat programkdols mellett nagyon fontos a forrsfjlok
dokumentlsa. A dokumentcis tpus megjegyzseket a /** */ jelek
kztt kell elhelyeznnk, az adott csomag, osztly, illetve ezen bell az
adattagok vagy metdusok defincija eltt.
A szvegkiemelst tmogat szerkesztk hasznlatval a megjegyzsek
jl elklnlnek a forrskd tbbi rsztl. Az objektumorientlt modellek leprogramozsakor az ltalnos interfszektl, az absztrakt osztlyokon t jutunk el a megvalstst hordoz konkrt osztlyok definilsig.
A felldefinilt s felltlttt metdusok teht megjelenhetnek ltalnos s
konkrt rtelemben is. Ezrt mindig meg kell adnunk, hogy a definils
alatt ll programelem milyen funkcikat tlt be, milyen paramtereket
fogad, milyen visszatrsi rtket szolgltat, illetve a definci sorn milyen
mveletet, algoritmust szeretnnk az adott programrsszel vgrehajtani.
Egy forrs ksbbi mdostsa, vagy a ms fejlesztk munkjnak elsegtse ezen kommentekkel biztosthat s a hatkony csoportmunka
elengedhetetlen rsze.
Az elkszlt s jl dokumentlt forrsfjlokat a dokumentcis segdprogramokkal nthetjk szerkesztett formba. Ezek a segdprogramok a
Vissza
218
Programozs III.
Mellkletek
Vissza
219
fordtk ltal kihagyott megjegyzsek feldolgozst s valamilyen kimeneti

formtumba val konvertlst vgzik el. Ilyen ingyenes segdprogramok a
Java keretrendszerhez fejlesztett javadoc s az ltalnos (tbb nyelvhez
hasznlhat) doxygen [2],[7].
13.2.1. javadoc
A javadoc segdprogramot parancssoros krnyezetbl indthatjuk a

javadoc Osztaly.java
javadoc *.java
javadoc *.java d dokumentacio version author -protected
parancs segtsgvel. A megadott osztlyok forrskdjaibl a csomag, osztly s az adattagok, metdusok szerkezett megvizsglja, majd a dokumentcis megjegyzseket a megadott elemekhez kapcsolja. Kimenetknt
az adott knyvtrban egy jl formzott html szerkezetet kszt, melynek
kiindulpontja az index.html fjl lesz. A javadoc kapcsolival a kimenet tartalmi formtumait adhatjuk meg:
Opci
-d
-version
-author
-use
-public
-protected
-package
-private
-overview
<file>
-subpackages
Jelents
kimeneti knyvtr neve
bekapcsolhatk a @version tag-ek
bekapcsolhatk a @author tag-ek
bekapcsolhatk a dokumentci keresztreferencii
(ms osztlyok is importlhtak)
csak a publikus hozzfrs tagokat jelenti meg
a protected s public tagokat mutatja
a csoport hozzfrs s protected s public tagokat
mutatja
minden tagot megmutat a dokumentciban
egy ttekint oldalt fz a dokumentci elejre a megadott html fjlbl
rekurzv mdon a megadott alcsomagok osztlyai is
kifejtsre kerlnek
stb.
Vissza
219
Programozs III.
Mellkletek
Vissza
220
A forrsfjlokban az albbi javadoc kapcsolkat (tag-ek) helyezhetjk el az

egyes lersokban. Egyes tag-ek az osztly, mg msok az adattagok vagy
metdusok lerst segtik.
javadoc tag
Lers
Az -author kapcsol hasznlatval megadhat a forrs
@author
szerzje/ tulajdonosa.
Konstruktorok s metdusok paramtereinek lersra
@param
hasznlhat.
Megadhat, hogy a metdus milyen visszatrsi rtket
@return
szolgltat.
Hiperlink hivatkozs fzhet a dokumentumba, amely egy
@see
msik osztlyra mutat.
Megadhat, hogy az adott metdus milyen kivteleket
@throws
vlthat ki.
@exception Megegyezik a @throws tag-gel
@deprecated Egy Deprecated bejegyzst helyez el a lersba. Ez a fejlesztknek azt jelzi, hogy az adott mvelet elavult, s csak
kompatibilitsi szempontok szerint maradt a definciban.
ltalban az j s hatkonyabb mveletek kivltjk az
elavult metdusokat.
Egy kls hiperlink hivatkozs fzhet a dokumentumba,
@link
amely egy msik html oldalra mutat.
Egy Since bejegyzst helyez el a dokumentumban. A cso@since
magok s az osztlyok fejlesztsnl megadhat, hogy az
adott tulajdonsg melyik verzi ta rsze a defincinak.
Egy version bejegyzst helyez el a dokumentumban, ha a @version
version opci aktv. Ezzel a szoftver letciklusa, fbb fejlesztsi lpsei jelezhetek.
8. tblzat: a javadoc vezrlelemei
A sikeres dokumentci elksztse utn az osztlyknyvtrak dokumentciihoz hasonl oldalakat kapunk, amelyet tetszleges bngszvel megtekinthetnk:
Vissza
220
Programozs III.
Mellkletek
Vissza
221
31. bra: javadoc programmal generlt html dokumentci

13.2.2. doxygen
A javadoc-hoz hasonlan ms szoftverek is kpesek egy megfelelen

kommnetezett forrskdbl dokumentcit kszteni.
A doxygen egy keresztplatformos dokumentci-kszt rendszer, tbbfle programozsi nyelvhez alkalmazhat (C, C++, Java, Objective-C,
Python, IDL , Corba, PHP, C#).
A programmal generlhat dokumentci kimeneti formtuma a kvetkezk valamelyike lehet:
HTML
LATEX
PostScript (a LATEX fjlbl konvertlhat)
Pdf (a LATEX fjlbl konvertlhat)
RTF
CHM (Microsoft sg formtum)
XML
Vissza
221
Programozs III.
Mellkletek
Vissza
222
A doxygen szmos nyelven gy magyarul is kpes dokumentci sablonokat generlni. Az elkszlt s megfelelen dokumentlt forrsfjlokat
a doxygen segtsgvel parancssorbl, vagy grafikus felletrl indthatjuk.
(Rszletes hasznlati tmutat a program sgjban tallhat.)
Vissza
222
Programozs III.
Irodalomjegyzk
Vissza
223
Irodalomjegyzk
[Angster01] Angster Erzsbet: Objektumorientlt tervezs s programozs. Budapest : 4Kr Bt., 2001. 1020p. ISBN: 963 00 62623
[Cormen01] T. H. Cormen Ch. E. Leiserson R. L. Rivest : Algoritmusok. Budapest : Mszaki Knyvkiad, 2001. 884p.
ISBN: 963 16 3029 3
[Flanagan05] David Flanagan: JAVA in a nutshell, fifth edition. O'Reilly
Media Inc., 2005. ISBN: 0-596-007733-6
[Kondorosi04] Kondorosi Lszl Szirmay Kalos: Objektumorientlt szoftverfejleszts. Budapest : Computerbooks, 2004.
ISBN: 963 618 108 X
[Lemay02] Lemay, Laura Cadenhead, Rogers: Teach yourself in Java 2 in
21 days. Elektronikus jegyzet, 2002.
http://www.cadenhead.org/book/21java/
[Marton02] Marton Lszl - Fehrvri Arnold : Algoritmusok s adatstruktrk. Gyr : Novadat Bt., 2002. 344 p. ISBN: 963 9056 332
[Nyky01] Java2 tikalauz programozknak : Nykyn Gaizler Judit
(szerk.) et al. Budapest : ELTE TTK Hallgati alaptvny, 2001.
1400p. ISBN: 963 463 485 0
[Nyky03] Programozsi nyelvek: Nykyn Gaizler Judit (szerk.) et al.
Budapest, Kiskapu Kft., 2003. 760p. ISBN: 963 9301 477
[Schildt03] Schildt, Herbert : Java 2: A beginners guide 2nd edition :
McGraw-Hill Osborne Media, 2003. Elektronikus jegyzet 544p.
http://www.osborne.com/downloads/downloads.shtml
[Vg99] Vg Csaba Juhsz Istvn: Java start! Debrecen : Logos 2000,
1999. 228p. ISBN 963 03 9005 1
Vissza
223
Programozs III.
Irodalomjegyzk
Vissza
224
Online hivatkozsok:
[1] A Java nyelv trtnete:
http://java.com/en/javahistory/
[2] Doxygen dokumentcis segdprogram:
http://www.doxygen.org
[3] Az UML 2.0 szabvny:
http://www.uml.org/
[4] Java editorok s IDE eszkzk sszefoglal lersa:
http://java.about.com/od/idesandeditors/ ,
http://www.javaworld.com/javaworld/tools/jw-tools-ide.html
[5] Java just in time (JIT) interpreter s krnyezet
http://www.shudo.net/jit/
[6] Java kdolsi konvencik:
http://java.sun.com/docs/codeconv/, illetve magyarul:
http://dragon.unideb.hu/~vicziani/pdf/jkk.pdf
[7] Javadoc segdprogram:
http://java.sun.com/j2se/javadoc/
[8] Java Tutorial:
http://java.sun.com/docs/books/tutorial/index.html
[9] Thinking in Java 3rd edition (Bruce Eckels):
http://www.mindview.net/Books/TIJ/
[10] A Java nyelv hivatalos weboldala:
http://java.sun.com
[11] J2SE 1.4 Merlin Release Contents JSR 59. 2002.05.09:
http://jcp.org/en/jsr/detail?id=59
[12] J2SE 5.0 Tiger Feature List JSR 176. 2004.09.30:
http://jcp.org/en/jsr/detail?id=176
[13] Java SE 6 "Mustang" Release Contents JSR 270 (beta version
2005.12.21): http://jcp.org/en/jsr/detail?id=270
[14] How to Write Doc Comments for Javadoc
http://java.sun.com/products/jdk/javadoc/writingdoccomments.html
Vissza
224
Programozs III.
Trgymutat
Vissza
225
Trgymutat
A,
abstract 96
absztrakt metdus 27, 96
absztrakt osztly 27, 104
absztrakt osztlyok 96
adatrejts 24
adattag 76
aggregci 35
alaprtelmezett konstruktor 90
alaptpus 41
alcsomag 115
args[] 100
ArrayBlockingQueue 159
arraycopy 142
ArrayIndexOutOfBoundsExcepti
on 128
ArrayList 149, 155
Arrays 142
asszocici 34
Asszociatv adatszerkezetek 146
B
belpsi pont 100

bels osztly 110
binris keress 143
binris keress tmbben 142
binarySearch 143
BitSet 153
Boolean 68
BufferedInputStream 177
BufferedOutputStream 177
BufferedReader 180
BufferedWriter 180
ByteArrayInputStream 177
ByteArrayOutputStream 177
Calendar 132, 137

catch 125, 128
Character 68, 151
CharArrayReader 180
CharArrayWriter 180
class member 98
class method 98
ClassCastException 153
classFinalize 81
CLASSPATH 117, 120, 121
Collection 148
Comparable 105, 143, 151, 152,
159, 160, 169
compare 143
compareTo 153
compateTo 143
ConsoleHandler 133
copy constructor 91
currentTimeMillis 141
Cs
csomag 115, 118

csomag bvtse 119
csomagdeklarci 119
csomagol osztly 169
csomagol osztlyok 68
D
data hiding 24
DatagramPacket 188
DatagramSocket 185, 188
DataInputStream 177
DataOutputStream 177
Date 132, 137
Vissza
225
Programozs III.
Trgymutat
dtummveletek 136
default constructor 90
DelayQueue 159
destruktor 80
dokumentci
doxygen 221
javadoc 219
Double 68
dynamic method dispatch 88
E,
early binding 32
egysgbe zrtsg 77
egysgbezrs 23
elemi tpus 41
elemi tpusok 85
elfeds 101
ellenrztt kivtel 123, 125
encapsulation 23
entrySet 160
enum 69
haszlata 72
kiterjesztse 73
tpus definci 70
Enumeration 161
EnumMap 161
EnumSet 154
Ers tartalmazs 35
error 123
escape szekvencik 63
exception 123
Exception 124, 128
explicit tpuskonverzi 86
export 122
export CLASSPATH 118
extends 81, 109, 169
Externelizable 182
Vissza
226
fjlkezels 172
Felsorolt tpus 69
felldefinils 86
felltlts 89
felltlttt konstruktorokat 90
File 172
FileHandler 133
FileInputStream 176
FileNotFoundException 176
FileOutputStream 176
FileReader 180
FileWriter 180
fill 144
FilterInputStream 177
FilterOutputStream 177
FilterReader 180
FilterWriter 180
finalize 81
finally 128
Float 68
foglalat 184
folyam 174
fordtsi egysg 118, 120
format 132, 138
Formatter 133
futs alatti kts 32, 88
G
garbage collect 81
generic method 163
generic type 163
generikus tpus definilsa 167
generikus tpusok 161
GMT 136
Gy
Gyenge tartalmazs 35
Vissza
226
Programozs III.
Trgymutat
Vissza
Hls adatszerkezetek 147

hlzatkezels 172
Handler 133
HashMap 149, 159
HashSet 149, 150, 153
Hashtable 159
HashTable 149
hasttbla 159
Hierarchikus adatszerkezetek 146
hozzfrsi kategrik 82
csomagszint 50
private 51
protected 51
public 50
http 183
jar 120, 121

java archive 120
Java Community Process 12
java.io 172
java.net 183
java.util.logging 132
I,
I/O 175
IdentityHashMap 160
import 117
inheritance 25
InputStream 175
InputStreamReader 180
instaceof 48
Integer 68
interface 105
interfsz 104
deklarci 105
implementls 105
implemetlsa 106
rkldse 109
Interfsz 29
interpreter 11
IOException 176, 181
ismertsgi kapcsolatban 34
Iterator 161
227
227
karakter tpus 63
ksi kts 88
keySet 160
kivtel 123
kivteles esemny 124
komponens 37
kompozci 35
kontner 35
L
late binding 32
lekpezs 159
Level 133
LineNumberReader 180
LinkedBlockingQueue 159
LinkedHashSet 153
LinkedList 149, 157, 158
List 163
ListIterator 162
Locale 139
Logger 133
LogManager 133
LogRecord 133
Long 68
M
main 100
manifest 120
Map 159, 161
msol konstruktor 91
Vissza
Programozs III.
Trgymutat
Math.PI 96, 99
MemoryHandler 133
metdus 76, 78
mveletek
precedencia 48
N
namespace 115
nanoTime 141
naplzs 132
nem ellenrztt kivtel 125
nvtelen csomag 118
new 80
null referencia 80
Number 169
O,
Object 18, 21, 24, 33, 49, 81, 83,

85, 86, 87, 89, 111, 144, 148,
152, 153, 164, 175, 199, 205,
210, 215
Object osztly 83
ObjectInputStream 177, 182
ObjectOutputStream 177, 182
objektum 19
osztly 19
absztrakt 27, 95
betltse 79
definci 78
pldnyosts 22
Osztly 44
osztlymetdus 99
osztlymetdusok 97
osztlyvltoz 101
osztlyvltozk 97
osztylmetdus 101
OutputStream 175
OutputStreamWriter 180
overload 30, 89
Vissza
228
override 31, 86
,
rklds 25, 81
sszekttets alap hlzat 183
sszekttets-mentes hlzat 183,
188
P
package 118, 119

parancssori paramterek 101
pldnyosts 76, 80
PipedInputStream 177
PipedOutputStream 177
polimorfizmus 85
polimorphism 29
printf 130, 132, 138
PrintStream 130, 177
PrintWriter 130, 132, 181
PriorityBlockingQueue 159
PriorityQueue 159
public 100
PushBackReader 180
Q
Queue 158
R
RandomAccessFile 183
Reader 175, 180
referencia 80, 85
rt.jar 117
runtime binding 32
RuntimeException 124, 128
S
Serializable 182
ServerSocket 185, 187
SET 122
SET CLASSPATH 118
Vissza
228
Programozs III.
Trgymutat
SimpleTimeZone 137
socket 184
Socket 185
SocketHandler 133
sorvgjel 132
src.zip 117
Stack 156
static 98, 99
static final 98
statikus kts 101
stream 174
StreamHandler 133
StreamTokenizer 181
String 64, 132, 143
StringBuffer 67
Stringbuffer mdostsa 67
StringReader 180
StringWriter 180
super 51, 84, 87
switch 69, 72
SynchronousQueue 159
System.gc() 81
System.out 179
Sz
szekvencilis adatfeldolgozs 183

Szekvencilis adatszerkezetek 146
szemtgyjt 63
szemtgyjt mechanizmussal 81
szignatra 87, 88, 89, 91
T
tagfggvny 77
tagosztly
statikus 110
tagosztly 110
tagosztly
dinamikus 112
TCP/IP 183
Vissza
229
229
this 99
throw 40, 124, 126, 127, 129
Throwable 124
throws 126
throws IOException 176
TimeZone 137
tpuskonverzi 49
automatikus 49
explicit 49
szveges 49
toString 87
tbbalaksg 29, 85
dianikus tpus 29
felldefinils 31
felltlts 30
tmb 58
deklarci 58
rtkads 62
ltrehozsa 59
memriamodellje 60
sztringekbl 65
tbbdimenzis 60
tmb rendezse 142
tmbmsols 142
tmbk inicializlsa 142
TreeeSet 159
TreeMap 149, 159, 160
TreeSet 149, 151, 160
try-catch 127, 176
TT_EOF 182
TT_EOL 182
TT_NUMBER 182
TT_WORD 182
U,
UNIX id 136
URL 191
UTC 136
Vissza
Programozs III.
Trgymutat
vltozk elfedse 47
Vector 86, 119, 120, 149, 155, 156
vezrlsi szerkezetek 51
ciklus 55
elgazs 52
esetsztvlaszts 54
feltteles kifejezs 52
szelekci 54
Vissza
230
Vissza
230
virtulis gp 12
VMT 33
W
wrapper class 68
Writer 175, 180

Programozas III

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Programozas III

Uploaded by

Copyright:

Available Formats

Varjasi Norbert

Kszlt a HEFOP 3.3.1-P.-2004-09-0102/1.0 plyzat tmogatsval.

Varjasi Norbert, 2006

Marton Lszl emlkre

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

Kattintsunk a tartalomjegyzk megfelel pontjra, ezzel az adott fejezet

Keressk meg a trgyszavak kztt a bejegyzst, majd kattintsunk a hozz

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

5.3. Interfszek rkldse ............................................................................109

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

10. Az I/O s hlzatkezels...........................................................172

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

elterjedt kzvetlen adatcsert lehetv tev (peer-to-peer) szoftverek vltjk fel.

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

angol nyelv knyv, [Angster01, Flanagan05, Kondorosi04, Lemay02,

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

A Java nyelv alapjai

1. A Java nyelv alapjai

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

A Java nyelv alapjai

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

A Java nyelv alapjai

1999-ben a Java2 rendszer kiadsakor mr hrom fggetlen rszre

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

A Java nyelv alapjai

Ugyanaz a Java forrsprogram brmilyen fordtval lefordtva ugyanazt

1. bra: Java programok fordtsa s futtatsa a virtulis gpen

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

A Java nyelv alapjai

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

A Java nyelv alapjai

Milyen formtum egy lefordtott java forrs?

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

Az objektumszemllet elmleti megkzeltse

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

Az objektumszemllet elmleti megkzeltse

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

tllpse, hiszen a tlsgosan bonyolultt vl rendszerek modellezsre,

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

Az objektumszemllet elmleti megkzeltse

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

Az objektumszemllet elmleti megkzeltse

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

objektumok tulajdonsgait megvltoztathatja, vagy valamely ms objektum

2. bra: Egy osztly s objektumai (modell)

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

Az objektumszemllet elmleti megkzeltse

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

Az brn fkat vizsglunk. Minden fa egyedi, hiszen megllapthatunk

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

Az objektumszemllet elmleti megkzeltse

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

3. bra: Az osztly jellse

4. bra: Az objektum (pldny) jellse

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

Az objektumszemllet elmleti megkzeltse

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat

Az zenet az objektumok kztti kommunikci, adatcsere, illetve egy

Az osztlyok grafikus megjelentshez az egysges modellez nyelv - az

A dokumentum hasznlata | Tartalomjegyzk | Trgymutat