Juhász István PROGRAMOZÁS 2

Átírás

1 Juhász István PROGRAMOZÁS 2 mobidiák könyvtár

2

3 Juhász István Programozás 2

4 mobidiák könyvtár SOROZATSZERKESZTŐ Fazekas István

5 Juhász István Programozás 2 Egyetemi jegyzet Első kiadás mobidiák könyvtár Debreceni Egyetem Informatikai Intézet

6 Lektor Espák Miklós Debreceni Egyetem Copyright Juhász István 2004 Copyright elektronikus közlés mobidiák könyvtár, 2004 mobidiák könyvtár Debreceni Egyetem Informatikai Intézet 4010 Debrecen, Pf A mű egyéni tanulmányozás céljára szabadon letölthető. Minden egyéb felhasználás csak a szerző előzetes írásbeli engedélyével történhet. A mű A mobidiák önszervező mobil portál (IKTA, OMFB-00373/2003) és a GNU Iterátor, a legújabb generációs portál szoftver (ITEM, 50/2003) projektek keretében készült.

7 2. OBJEKTUMORIENTÁLTSÁG Meg fogunk állni a programozási nyelvek szintjén. Az objektum-orientált programozási módszertan filozófiáját amelynek alapgondolata, hogy az adat és a funkcionális modell egymástól elválaszthatatlan, lényegében egyetlen modell követik az objektum-orientált programozási nyelvek. Az OO programozási nyelvek imperatív jellegűek: algoritmikus szemléletet tükröznek. Az OO paradigma bevonul minden más nyelvi osztályba is. A 60-as évek második felében jelenik meg a SIMULA67-ben az OO programozási eszközrendszer. A SIMULA67: Algol verzió, szimulációs, absztrakciós nyelv, minden objektum-orientált eszköz megvan benne. Észak-Európában születik meg. Alan Kay amerikai egyetemista 1969-ben szakdolgozatában egy új világot vázol föl: az OO világot. A Xerox-nál próbálja megvalósítani. Egy projektet szervez, melynek célkitűzése egy személyi számítógép megtervezése (hardver, architektúra, szoftver). Ő használja az objektum-orientált elnevezést, fogalmakat. (A grafikus interfész, ablak és egér fogalma is ekkor jelent meg először.) Felvázol egy projektet: csinálni kell személyi számítógépet Windows típusú operációs rendszert, grafikus felhasználói felületet (ekkor még csak az elektromos írógép az input periféria) mindezt objektum-orientált programozási környezetben 1970-es évek elején megszületik a Xerox-nál a Smalltalk programozási nyelv, melyet objektum-orientáltnak terveznek, tiszta objektum-orientált nyelv, (SIMULA elemekkel). A világot csak objektum-orientáltnak hagyja láttatni, másnak nem. Ekkor még a strukturált elv a döntő.a Smalltatkkal együtt megjelenik egy olyan paradigma, amelyet a szakma még nem tud befogadni, másrészt olyan hardver kell alá, ami még nem létezik. A 80-as évek második felétől jelenik meg ilyen hardver. Ezután őrültmód elkezd terjedni az OO. Divattá válik. A Smalltalk napjainkban is él. Megszületik a 80-as években a C++, jelenleg divatnyelv ben megjelenik a Meyer által kifejlesztett Eiffel nyelv, ami az OO területén azt a szerepet játsza, amit az eljárásorientált nyelvek területén a Algol. Nincs gyakorlati jelentősége. 1989: Turbo Pascal : Turbo Pascal 6.0: OO eszközrendszerrel rendelkezik. A 80-as évek második

8 felében 90-es évek első felében minden magára valamit is adó programozási nyelvnek van olyan változata, amely már OO eszközrendszerrel rendelkezik valamilyen szinten. Java: az OO vallásának istene. A C++ óta egyetlen, aminek gyakorlati jelentősége is van. Objektum-orientáltság jellemzői: az adatmodell és az eljárásmodell elválaszthatatlan (így szemléli a világot) absztrakt eszköz és fogalomrendszer: Az újrafelhasználhatóságot olyan magas szintre elviszi, ameddig lehetséges, a valós világot nagyon megközelíti. szemlélete: imperatív (algoritmus kódolni kell) eszközrendszer Jelen pillanatban az OO területén többféle iskola létezik, amelyek bizonyos pontokon élesen vitatkoznak egymással, nem csak nüansznyi különbségek vannak köztük. Jelen pillanatban folyik az OO matematikai hátterének elkészítése, kifejlesztése. Az objektum-orientált programnyelvek fogalomrendszere Objektum (object): Az eljárásorientált nyelvek változó fogalmának kiterjesztése (általánosítása), olyan konkrét programozási eszköz melynek vannak: Attribútumai (attribute): ez az adatrész, a struktúra, tetszőleges bonyolultságú adatszerkezet. Szokás ezt az objektum statikus részének is nevezni. Minden objektum mögött van egy jól definiált tárterület, ezen vannak az attribútumok értékeit reprezentáló bitsorozatok. Terminológia: az obektumok állapotairól (state) beszélünk, ahol minden egyes állapotot egy-egy bitkombináció ír le, ami egy jóldefiniált címen van. Módszerei (method): a viselkedés leírására szolgál (eljárásmodell leírására) az eljárásorientált nyelvek eljárásai és függvényei. A módszerek adják meg nyelvi szinten az objektum viselkedésmódját (behavior). Azonossággal rendelkezik (van azonosság tudata): bármely objektum csak és kizárólag önmagával azonos, minden mástól megkülönböztetett. Minden objektumnak van azonosítója (OID: object identifier). Nyelvi

9 szinten ezzel nem foglakozunk. Analógia: változó név objektum OID (nem egy név!) A változó neve igazából soha nem azonosító csak hatáskörön belül egyértelmű a névhivatkozás. Az OID viszont tényleg egyedi, még programok között is! Objektum viselkedése: Az objektum állapota időben módosul(hat). Módszerek csoportjai: le tudja kérdezni az objektum állapotát meg tudja változtatni az objektum állapotát Objektumok élettartama: Az objektumot létre kell hozni, és addig él, amíg meg nem szűnik. A megszüntetés lehet a nyelvi rendszer feladata, vagy a programozóé. Az objektumazonosító minden szinten él, mindig léteznie kell. Osztály (class): Absztrakt eszköz, az eljárásorientált nyelvek típusfogalmának általánosítása (gyakran itt is típusként említjük - szinonimák). Az osztály absztrakt adattípus abban az értelemben, aholy az Adában a korlátozott privát típust használjuk. Az osztály azonos attribútumú és módszerű objektumok együttese. Az osztályhoz köthetőek az objektumok; az osztályból származtathatóak az objektumok. Példány (instance): Az osztályon belül létrehozok egy objektumot: példányosítás (instantiation). Az adott objektum adott osztály példánya. Minden objektum tudja, hogy melyik osztálynak példánya. Adott osztályhoz tartozó minden példány ugyanolyan attribútumokkal és módszerekkel rendelkezik. Minden példány tudja, hogy milyen módszerekkel rendelkezik. A módszereket mindig konkrét példányon futtathatom le, ezen értelmezhetők: az aktuális példányon.

10 Példány létrehozása: ugyanaz az adatszerkezet újra és újra megjelenik a tárban. A módszereket nem többszörözi! Létezhetnek olyan attribútumok és olyan módszerek, amelyek nem arra szolgálnak, hogy az egyes példányok állapotait és viselkedését vizsgáljuk velük, hanem magához az osztályhoz tartoznak. (Példányattribútum, példánymódszer; osztályattribútum, osztálymódszer) Osztályattribútum: hány darab példánya van (az osztály kiterjedése). Az osztályattribútumok nem többszöröződnek. Az OO szemlélet szerint először létre kell hozni egy osztályt, leírni, hogy a hozzá tartozó objektumoknak milyen attribútumai és módszerei legyenek. És ezek után az osztályhoz kapcsolódóan és osztályon belül létre lehet hozni objektumokat. Példányosítás után az osztály példányairól beszélünk. Öröklődés (inheritance): Az újrafelhasználhatóság eddig legteljesebb válasza: objektum-orientált programozási elv: az osztályok nem függetlenek egymástól, speciális viszony értelmezhető közöttük, ez az öröklődés. Ez a viszony aszimmetrikus. (Az absztrakciót a lehető legmesszebb elviszi, viszont a párhuzamosságra nem ad választ, bár az objektumok párhuzamosan léteznek. Nyelvi szinten nem mindenhol jelenik meg ez explicit módon. Az adatfolyamnyelvek adják a párhuzamosságra a legpozitívabb választ.) Az öröklődés osztályokhoz kötött fogalom: két vagy több osztály között értelmezhető.a szuperosztályhoz kapcsolódóan tudunk létrehozni alosztályokat. szuperosztály (superclass) / szülőosztály / ősosztály / alaposztály alosztály (subclass) / gyerekosztály / származtatott osztály Az alosztály átveszi, örökli a szuperosztály attribútumait és módszereit (azokat, amelyeket a láthatóság módszerével nem tiltottunk le). Öröklésnél azonnal megvan az újrafelhasználhatóság, rendelkezésre áll az összes eszköz. Az alosztály ezen túlmenően: új attribútumokat vezethet be új módszereket vezethet be újraimplementálhatja a módszereket törölhet attribútumokat törölhet módszereket a láthatósági szabályokat újraértelmezheti, hatásukat felfüggesztheti átnevezhet attribútumokat duplikálhat attribútumokat duplikálhat módszereket

11 Öröklés: valamit egy az egyben átvehetek, ha akarom, módosíthatom. Aszimmetria: a szuperosztály nem látja, nem manipulálhatja alosztályait, de fordítva igen. A szuperosztályt teljes mértékben látja az alosztály. Az alosztály minden objektuma objektuma a szuperosztálynak is! Viszont fordítva ez nem áll fenn. Így minden rendszerben: mindenütt, ahol egy szuperosztály egy példánya szerepel, szerepelhet az alosztály egy példánya is és fordítva nem igaz. Egy osztályból tetszőleges számú alosztály származtatható minden nyelvben. Az egyes rendszerekben kérdés, hogy: az alosztálynak hány szuperosztálya lehet? egy: egyszeres öröklődés (single) akárhány: többszörös öröklődés (multiple). Problémák: azonos nevű attribútumok, módszerek esetén: névütközés; ezt a rendszernek kezelnie kell. Rendszerfüggő, hogy hogyan teszi. Alosztályból másik alosztály származtatható: öröklési hierarchia. Ez egyszeres öröklődés esetén fa., többszörös öröklődés esetén aciklikus gráf. Öröklési fa: Alakzat Nyílt alakzat Zárt alakzat Poligon Ellipszis Háromszög Négyszög Ötszög Kör Például az Alakzat osztály attributumai lehetnek: vonalvastagság, nagyság, szín, háttér, kitöltöttség... módszerei lehetnek: kirajzol( ), elforgat( ) Az Alakzatot elkezdem specializálni, ekkor a Zárt alakzatnál jöhetnek mégújabb jellemzők: terület, kerület módszerek: területszámítás( ), kerületszámítás( ) A Zárt alakzat Alakzat is egyben, így a Zárt alakzat minden példánya az Alakzatnak is példánya (is_a). A Háromszögnek is lehet egy terület( ) módszere: átveszem a Zárt alakzattól, de ezt újraimplementálom, hiszen a Zárt alakzat területét csupán közelítőleg tudom megadni, míg a Háromszögét pontosan.

12 Terminológia: Fa gyökéreleme: ősosztály, amiből az összes többi származik. Előd: pl. a Kör elődjei: Ellipszis, Zárt alakzat, Alakzat. Leszármazott: pl. a Zárt alakzat leszármazottjai: Ellipszis, Kör. Kliens osztályok: azok az osztályok, amelyek között nincsen öröklődési kapcsolat. Pl. Kör Ötszög. Bezárás (encapsulation): Az OO nyelvek legkényesebb fogalma: általában e fogalom mentén válnak el az iskolák, attól függően, hogy melyik mit vall róla. Az eljárásorientált nyelvek hatáskör fogalmának, a láthatóságnak a kiterjesztése. A legtöbbet félreértelmezett fogalom. Nem objektumhoz kapcsolódik. Bezárás_1: Nem objektumhoz kötődik. Az osztály egy absztrakt adattípus. Az osztály rendelkezik egy interfész és implementációs résszel. Az osztály objektumaihoz csak az interfész részen keresztül férhetünk hozzá, az implementációhoz egyáltalán nem, korlátozott hozáférést jelent. Ez az információrejtés elve (Information hiding). Egy osztály objektumai egy az osztály által definiált interfészen keresztül érhetők el, és csak így! A nyelv a benne definiált attributumokat és metódusokat két részre osztja: Nyilvános rész: amelybe tartozó eszközöket minden kliens osztály lát. Privát rész: kívülről nem látható. Bezárás_2: A bezárás eljárásorientált nyelvek hatáskör fogalmának általánosítása OO körökben, ahol garantáltan létezik egy olyan eszközrendszer, mellyel a programozó tudja szabályozni, hogy az osztályból mi látható és ki számára. Polimorfizmus (polimorphism): vagyis többalakúság. Kétfajta polimorfizmus van: Objektum polimorfizmus: Minden objektum tudja saját magáról, hogy melyik osztály példányaként jött létre. Egy objektum objektuma saját osztályának, de az öröklődési hierarchiában objektuma valamennyi elődosztálynak is egyben. Így minden egyes objektum szerepelhet minden olyan szituációban, ahol az ősosztály objektuma szerepelhet, nem csak a saját osztálya példányaként használható. Módszerpolimorfizmus (overriding): Egy leszármazott osztály egy örökölt módszert újraimplementálhat: a módszer specifikációja változatlan marad, de az implementáció más lehet az öröklődéi vonalon. Ld.: Zárt alakzat: terület( ), kerület( ) módszer Háromszög: terület( ), kerület( ) módszer más! (új implementáció)

13 Kötés (binding): A módszerpolimorfizmushoz kapcsolódik. Ha van egy függvény és több implementáció hozzá, kérdés, hogy mikor melyik kód kapcsolódik a specifikációhoz. Eszerint beszélünk: Statikus (static) más néven korai (early) kötésről: a névhez a kód hozzárendelődik fordítási időben. Az OO rendszerek többsége fordítóprogram orientált. Dinamikus (dynamic) vagy késői (late) kötésről: kötés futási időben történik, így ugyanahhoz a névhez más-más kód tartozhat, attól függően, hogy melyik osztálykörnyezetben dolgozunk: az aktuális példány osztályában definiált kód, vagy (ha nincs) a hierarchián felfele a legközelebbi kód kötődik. A nyelvek többsége mindkét kötést ismeri, kérdés, hogy melyik az alapértelmezett. Üzenet (message): Tipikusan Smalltalk fogalom. A Smalltalk filozófia szerint az objektum üzenetek segítségével kezelhető. Ha az objektumtól kérni akarok valamit, akkor üzenetet küldök. Az objektum veszi az üzenetet, én nem tudom, mi történik közben, nem tudom, hogy az objektum hogyan találja ki a választ, és az objektum válaszol. Absztrakt osztályok Absztrakt osztályoknak hívjuk azokat az osztályokat, amelyeknek nincsenek példányaik, amelyek nem példányosíthatók. Csak örököltetésre való. Beszélnek nyelvek absztrakt módszerekről. Ezek azok a módszerek, amelyeknek csak a specifikációjuk van megadva implementáció nélkül. Az abszrakt osztályokból konkrét, példányosítható osztályok származtathatók. Az egész eszközrendszer az absztrakciót szolgálja. A rendszerfejlesztési ciklusban és a programfejlesztésnél lesz érdekes. Konténer osztályok (Container) Olyan adatszerkezet, amely objektumokat tartalmaz. Alapvető a tömb, láncolt lista, verem, sor, stb. Nem minden nyelvben vannak realizálva a konténer osztályok, a programozónak kell megvalósítania. Alapvető szerepük az adatbáziskezelőknél van. Kollekciók (Kollection) Objektum-orientált adatbázisok esetén a konténerosztályok helyett a terminológia: kollekció (Collection). Ezen kollekcióval kapcsolatos az iterátor fogalma.

14 Iterátor Általában ez is egy osztály, típus, ennek példányaihoz tartozó objektumokat be tudjuk járni. A bejárás az adatszerkezeteknek megfelelően történik. Paraméterezett osztályok: Egyes objektum-orientált nyelvekben vannak ún. paraméterezett osztályok, a C++ terminológia szerint templatek. Lényegében megfelelnek osztályszinten az Ada generikusnak. Objektumok élettartama: A példányosítás mindig egy explicit tevékenység eredménye, minden objektumot minden nyelvben a programozó hoz létre. Meddig él? - A nyelvek egy részénél az objektumot megszüntetni is explicit módon kell, az objektumok törlése is a programozó feladata. A nem tisztán objektum-orientált nyelvek egy része vallja ezt az elvet. Ld. C++. - A nyelvek másik része (nagyobb része) alkalmaz egy automatikus objektum törlési mechanizmust (garbage collection), amelynek a feladata az objektumok megszüntetése aszinkron módon úgy, hogy azzal a programozónak ne kelljen foglalkoznia, és úgy, hogy a törölt objektumok tárhelye ismét felhasználható legyen. Ez az automatikus tárfelszabadítás nem csak az objektum-orientált nyelvek sajátja, hanem egy tárkezelési technika. Többféle algoritmus van arra, hogy a rendszer hogyan dönti el, hogy mely objektum törölhető. Nyilvánvaló, hogy garbage collection algoritmus sokkal kényelmesebbé teszi a programozást. Egységesség: A nyelvben létezik-e más eszközrendszer, mint az objektum? Minden objektum, vagy van olyan eszköz, ami nem az? Ezek alapján az OO nyelveknek két nagy csoportja van: A tisztán OO nyelvek azt vallják, hogy minden objektum (osztály, attribútum, módszer, objektum). Csak olyan eszközöket tartalmaznak, amelyek obektumorientáltak, és nincs más eszköz. Pl.: Smalltalk, Eiffel csak OO elvek alapján működik. A tisztán OO nyelvek esetén e nyelvi rendszer egyetlen osztályhierarchiából áll. Például a Smalltalk egy osztályhierarchia. A programozás pedig nem más, mint definiáljuk a saját osztályainkat, és azokat elhelyezem az osztályhierarchiában: az adott osztályhierarchiát bővítük, és ezekből

15 származtatunk objektumokat. A hibrid nyelvek alapvetően eljárásorientált, logikai, funkcionális, stb. nyelvi eszközöket tartalmaznak, és ez a nyelvi szközrendszer bővül OO eszközrendszerrel.van tehát objektum is, és van nem objektum is. Lehetnek bennük eljárásorientált, deklaratív, funkcionális, objektum-orientált eszközök. Programozhatunk benne objektumorientáltan is. A nem tisztán OO nyelvek nem tartalmaznak osztályokat, incs osztályhierarchia. Definiálhatunk önálló osztályokat, és egymástól fügetlen osztályhierarchiákat. Itt is vannak szabvány osztálykönyvtárak, csak ezek nem a nyelv részei, és ezektől fuggetlenül is lehet programozni. Majdnem minden nyelvnek van olyan kiterjesztése, amelyben szerepelnek OO eszközök. Ilyenek például az OO COBOL, Object Pascal, C++.

16 Terminológia: Objektum alapú nyelvek: (object-based) ha a nyelvben van objektum fogalom és bezárás, de nincs osztály és öröklés. (Pl. Ada) Osztály alapú nyelvek: (class-based) van osztály, bezárás, objektum fogalom, de nincs öröklődés. (Pl.: CLU) Objektum-orientált nyelvek: (object-orinted) minden létezik: bezárás, osztály, öröklődés fogalom. Ezek a nyelvek (imperatív nyelvként) fordítóprogramosak. És végül létezik az OO-nak egy olyan speciális nyelve, amelyben nincs osztály fogalom, de minden más OO eszköz megvan benne. Programozási nyelvek hierarchiája: (nyíl: származik, hatás; aláhúzás: objektum-orientált) ALGOL60 Pascal SIMU C SMALLT Objec Ada C++ Objec SMALLT Turbo SMALLT Ada Eiffel Java SMALLT Turbo Modul SMALLT Delphi Oberon VisualA ge

17 3. JAVA A Javát a SUN fejlesztette 1994-től. A Java, mint nyelv nyílt, heterogén, tetszőleges platformokat egyesítő elosztott rendszerek nyelveként születik meg. A C++ tökéletesítéseként jön létre. A Java megszünteti a C++ néhány eljárásorientált nyűgjét és a mutatóorientáltságot. Meghagyja a kifejezésorientáltságot. Tisztább objektum-orientált nyelv, mint a C++, majdnem tiszta OO nyelv, kevésbé hibrid nyelv. A Java tervezési célkitűzése a hordozhatóság. Fordítóprogramos, de a Javaban megírt forrásprogramot a Java-fordító ún. bájtkód formátumra fordítja le (ez a bájtkód hordozható), és ezt a lefordított programot pedig az ún. Java Virtuális Gép (Java Virtual Machine - JVM) futtatja le. A JVM tehát egy interpreter, de készíthető hozzá célhardver, amelynek gépi kódja a bájtkód, illetve megadható olyan fordító, amely a bájtkódot valamely konkrét gépi kódra fordítja le. Egyrészt a JVM tekinthető egy: - Absztrakt számítógépnek, amelynek a gépi kódja ez a bájtkód, és interpreteres, amelyet (általában szoftveresen) szimulálunk egy konkrét platformon. Ennek a koncepciónak a nagy előnye, hogy a Java programok hordozhatóak. Ugyanaz a bájtkód jön létre, ugyanaz a JVM van megírva minden platformon. Egységes. A JVM feloldja az egyes platformok közötti különbségeket. - Elképzelhető, hogy a JVM egy tényleges hardver, a bájtkód mögött egy célhardver van. És ezt a bájtkódot továbbfordítom egy adott processzor gépi kódjára.

18 A Java nyelv: - A Java meglehetősen magas szintre elviszi az absztrakciót. - Hálózati környezetben biztosítja az újrafelhasználhatóságot. - Párhuzamos programozást is lehetővé tesz.

19 A JAVA FILOZÓFIÁJÁN KERESZTÜL BEMUTATVA AZ OBJEKTUM-ORIENTÁLTSÁGOT Egyesíti az eddig tárgyalt fogalmakat. Karakterkészlet Az UNICODE 16 bites kódtáblán alapul, ahol betű minden nyelv betűje lehet. Tartalmazza az összes nemzetközi abc-t. Egy baj van, hogy a különböző platformok, az operációs rendszerek egy része ezzel az UNICODE-dal nem tudnak mit kezdeni, nem tudja kezelni ezt, tehát konkrét platformon ez az előny nem érvényesül. Ezért maradunk az eddig megszokott ASCII valamely változatánál. A kis- és nagybetűt megkülönbözteti. Azonosító Az azonosító fogalom a szokásos, azzal a megjegyzéssel, hogy betű nem csak az angol abc betűi, hanem a nemzetközi betűk, és az _ és $ jel is ide tartozik. Kulcsszavak Eléggé C++ szerűek. A CONST és a GOTO alapszó, de nincs implementálva, nincs mögötte semmi. Standard azonosító Nincs. Megjegyzés Háromféle megjegyzés formátummal dolgozik: - // -től sorvégéig megjegyzés.

20 - /* */ zárójelek között tetszőleges hosszan, ahol szóköz az elhatároló. - /** */ dokumentációs megjegyzés. (Ezzel nem foglalkozunk.) Címke A címke azonosító, utasítás előtt áll, kettősponttal elválasztva. Minden utasítás címkézhető. Típus: Nem objektumok Mivel léteznek a Javában olyan eszközök, amelyek nem objektumok, ezért majdnem tiszta OO nyelv. Ilyenek például: - Beépített típusok: - boolean - char - byte - short - int - long - float - double Ezek az eljárásorientáltság értelmében típusok. Nincs mutató típus, de van logikai. Ezek tartományainak elemei jelenhetnek meg literálként. Szerepük: változókat lehet velük deklarálni, amelyek szintén nem objektumok. Létezik tehát a Javában a hagyományos változó fogalom. - Beépített osztályok: az egyes típusok osztályváltozata, amelyek példányosíthatók. Nevük ugyanolyan, mint a beépített típusoké, annyi különbséggel, hogy ezek mindig nagybetűvel kezdődnek. Pl. Boolean, Char, Byte, stb. (Minden típusnak létezik az osztályváltozata.) A strukurált típusok közül létezik az egydimenziós tömb. Többdimenziós tömb nincs. Az index 0-tól indul. A név mögött [ ] zárójel jelzi, hogy tömbről van szó. Literál Léteznek C-szerű literálok, amelyek a beépített típusok értékkészletéből valók. - a : karakteres literál - alma : sztring literál

21 Beépített nevesített konstansok Ilyen például: - true, false - null objektum Nevük foglalt szó. Változó Változó deklaráció C-szerű: típus névlista; A deklarációban kifejezéssel kezdőérték adható a változóknak futási időben kiértékelődő kifejezéssel: int x=0; Automatikus kezdőértékadás nincs. Az inicializálást a Java megköveteli. Kifejezések A C kifejezés fogalmát veszi át a C++-on keresztül. C, C++ szerű a precedencia táblázat és kiértékelés, de a kiértékelést a hivatkozási nyelv szabályozza. Jóval kevesebb implementációfüggő rész van, mint a C-ben. Ha a C-ben meghívok két függvényt, és összeadom őket, akkor implementációfüggő a kiértékelés, de a Javában nem. Szigorúan típusos nyelv, azzal a megkötéssel, hogy a konverziót bizonyos esetekben megengedi (nem úgy, mint az Ada). Utasítások 1. A deklarációs rész csak változó deklarációból áll. 2. A végrehajtható utasítások: - Kifejezés utasítás. Ld. értékadó kifejezés. - Új objektum létrehozása. Példányosítás, ami a Java szempontjából egy művelet. Ld. precedencia táblázat. - Módszerhívás. - Vezérlő utasítások: ld. később. C, C++ szerű.

22 Blokk: - A blokk { } zárójelek között szerepel. - Cimkézhető. - Tetszőleges mélységben egymásba skatulyázható. - Változó blokk lokális változójaként deklarálható. - A blokkon belül tetszőleges a deklarációs- és végrehajtható utasítások sorrendje. - A lokális változók hatásköre statikus. Létezik lokális változó, de nincs lyuk a hatáskörben szituáció, mert a Java nem engedi meg az újradeklarálást. - Ezen változók élettartama dinamikus. A nemobjektumok szerepe a módszerek törzsén belül van. Vezérlő utasítások Feltételes utasítás IF(feltétel) utasítás ELSE utasítás; Teljesen C-szerű, annyi eltéréssel, hogy a C-vel ellentétben a feltétel logikai típusú. Többszörös elágaztatás SWITCH(egész_kifejezés) { CASE egész_literál: utasítások [CASE egész_literál: utasítások]... [DEFAULT: utasítások] } Előfeltételes ciklus WHILE(feltétel) utasítás; Végfeltételes ciklus DO utasítások WHILE(feltétel); Akkor ismétel, ha a feltétel igaz. Előírt lépésszámú ciklus FOR(p1; p2; p3) utasítás; Break utasítás BREAK[cimke];

23 A fenti konstrukciókban is ott vannak a blokkok. A break utasítás befejezteti azt a legbelső blokkot, amelyben ezt az utasítást kiadtam. Ha meg van adva az opcionális címke, akkor bármelyik szintről befejeztethetek egy egész blokksorozatot. Viszont módszerekből és inicializáló blokkokból nem lehet kilépni. Continue utasítás CONTINUE[címke]; Ciklusok esetén adható ki: a törzs hátralevő részét nem hajtja végre, hanem visszatér a vezérlő részhez, a fejhez. Ha szerepel a címke, akkor az adott címkéjű ciklus fejére tér rá a vezérlés. Return utasítás RTURN[kifejezés]; Függvényben kötelező a return kifejezés; Osztályok Az osztály egy absztrakt adattípus implementációja! A hangsúly a típuson van. A Java program legkisebb egysége az osztály, így a programozás az osztályok, megírásából áll. Az osztály egyben a legkisebb fordítási egység. Természetesen egy fordítási egység akárhány osztályt tartalmazhat, de egyet mindenképpen kell. Az osztályok csomagokba szervezhetők. Ha egy osztályt lefordítunk, meg kell mondani, hogy melyik csomag osztálya. (Még visszatérünk rá.) Egy osztály attribútumait változó deklarációk (adattagok data member), módszereit függvény definíciók alkotják (amely függvényeket a Java tagfüggvényeknek member function-nek hív). Közös néven tehát tagokról beszélünk. Egy Java osztály tagok segítségével építhető fel. Egy osztály minden példánya saját készlettel rendelkezik az adattagokból (példányváltozók). A példányosítás során az adatoknak megfelelő tárrész lefoglalódik. Ahány példány van, annyiszor foglalunk helyet a tárban. Egy osztály valamely módszerének meghívásánál meg kell adni, hogy melyik példányra hívtuk meg. Ez az aktuális példány. A Java ismeri a példányváltozó, példánymódszer illetve osztályváltozók és osztálymódszerek fogalmát. A példányváltozók a példányok állapotait, a módszerek a példányok viselkedését írják le. Az osztályváltozók és osztálymódszereket a Java statikus tagoknak hívja. Ezek magához az osztályhoz kapcsolódnak, az osztályváltozókból egy-egy van és az osztálymódszerek, ezeken dolgoznak. Ezek akkor is működnek, ha egyetlen példányuk sincs. Az osztály szerkezete:

24 - fej - törzs Fej: [módosító] CLASS név [EXTENDS szuperosztály_név] Absztrakt adattípus létrehozása a Javaban. A Java az egyszeres öröklődés elvét vallja. Ha nem adok meg szuperosztályt, akkor automatikusan az Object osztályhoz fog kapcsolódni az adott osztály. Az osztályhierarchia egy fa, amelynek gyökere az Object osztály. Terminológia: a Java időnként nem öröklődésről, hanem kiterjesztésről beszél. Módosítók a következők lehetnek: - abstract: absztrakt osztály definíció, nem példányosítható. - final: ennek segítségével olyan osztályt definiálunk, amely osztály nem kiterjeszthető. Az osztályhierarchiában levélelemet definiálunk ezzel, nem lehet belőle örökölni. - public: ezzel olyan osztályt definiálunk, amely bármelyik csomagból látható. (Egyébként csak abban, amelyikben van.) Több is szerepelhet belőlük értelemszerűen egyszerre: pl. abstract és final-nak nem lenne értelme. Törzs: { } zárójelben tetszőleges sorrendben tetszőleges számú tagdefiníció áll. Attribútumok Egy példányváltozó definíciója: [módosító] típus név [=kezdőérték] [,név [=kezdőérték]]... ; A kezdőérték kifejezés. Az objektum származtatáskor sem lehet hatrozatlan állapotban, alapállapotba kell hozni (ld. konstruktorok). Ha nincs explicit kezdőértékadás, akkor a fordító implicit kezdőértéket ad a példányváltozóknak: logikai típus esetén: false a többi beépített típus esetén: 0

25 objektum típus esetén: null értékre állít. A módosító: Itt is létezik final, amely egy konstans adattagot ír elő (nem változtatható adattag), vagyis ha egy explicit kezdőértékkel ellátott adattagot definiálunk, az nevesített konstans lesz. Ha final esetén nem adunk meg kezdőértéket, akkor ez egy üres nevesített konstans lesz, ennek kezdőértékét konstruktorral kell rögzíteni. A láthatóságot (a bezárást) a következő módon szabályozza: Alapértelmezés szerint (amikor nincs alapszó) friend azaz félnyilvános. Ekkor ez az adattag az adott csomagból látszik, ahol az osztályt elhelyeztem. A private (privát) alapszóval ellátott adattagot csak az adott osztály látja. Ezeket az osztály bezárja. Ha a protected (védett) az alapszó, akkor ezt csak a leszármazottak láthatják. A public (nyilvános) alapszóval deklarált adattag mindenhonnan látszik. Vannak még további módosítók, amelyekkel később foglalkozunk. Módszerek A módszerek definíciója a következőképpen néz ki: [módosító] fej törzs - A fejet szokás objektum-orientált körökben signature-nek (lenyomat, szignatúra) hívni (ez a korábbi specifikációnak felel meg), és a törzs a szokásos. Ld.: C, C++. (Kiegészül majd a kivételkezelésnél.) - A módosítók a példányváltozóknál megbeszéltek, plusz bejönnek újabb módosítók: - final: nem implementálható újra, nem polimorf. - abstract, mellyel absztrakt módszer definíciót írunk elő. Ilyenkor nincs törzs (implementáció), csak absztrakt osztályokban szerepelhet értelemszerűen. Valamely leszármazott adja meg az implementációt. Egy osztály mindaddig absztrakt, míg legalább egy módszere absztrakt. Absztrakt osztályokban szerepelhet nem absztrakt módszerdefiníció is. - A static módosítóval statikus tagokat definiálhatunk. - Itt is vannak további módosítók, amelyekkel később foglalkozunk. Az osztályon belül definiált módszerek látják az osztályon belül definiált minden adattagot. Amikor egy módszert meghívok, az nem más, mint egy függvényhvás. Paraméterkiértékelés módszereknél: - sorrendi kötés

26 - számbeli egyeztetés - típusegyeztetés Látni fogjuk, hogy e két utóbbi nagyon-nagyon lényeges. Paraméterátadás: A paraméterátadás értékszerinti. Hivatkozás Minősítéssel hivatkozunk egy tagra. csomagnév.osztálynév.objektumnév.tagnév Példa osztálydefincióra a Java útikalauzból: public class Alkalmazott{ String nev; int fizetes; void fizetesemel(int novekmeny){ fizetes = fizetes+novekmeny; } boolean tobbetkeresmint(alkalmazott masik){ } } return fizetes > masik.fizetes; - Van két példányváltozó: - név, ami a String osztály egy példánya - fizetes, ami egy egyszerű típusú adattag. - Van két példánymódszer: - fizetesemel : egy eljárás - tobbetkeresmint : egy függvény, benne return kifejezés;

27 Konvenció: - Az osztálynév nagybetűvel, - A tagnév kisbetűvel kezdődik. Módszer hívása: - Vagy kifejezés - vagy utasítás: valamit csinál, azaz mellékhatása van. System.out.println( szövegkiírás );

28 Példányosítás A new operátor segítségével történik, amely referencia típusú operátor. Amikor egy objektumot hozok létre, egy speciális változót definiálok. A változó neve segítségével nevezzük meg az objektumot.. Alkalmazott a; Definiálunk egy osztályt, az osztály ezáltal része lett a hierarchiának. Definiálhatok ilyen típusú változókat. Az a Alkalmazott típusú lesz. Ez nem példányosítás, nem rendelkezik értékkel. Amennyiben egy Alkalmazott osztálybeli példányt akarok definiálni, a következő módon tehetem meg: Alkalmazott a=new Alkalmazott(); Ekkor létrejön egy a nevű változó: lefoglalódik egy tárterület számára. A new hatására valahol hely foglalódik a példányváltozók számára, azok kezdőértéke beállításra kerül (a megírt vagy default Alkalmazott() konstruktor hatására), és az a változó értékül kapja a lefoglalt terület kezdőcímét. Ez azonban nem egy mutató típus. Ezt a Java referenciának hívja. Különbség a referencia és a mutató között: az a változó mindig a mögötte lévő objektumot fogja hivatkozni, nem címként kezelendő, értéke nem machinálható: nem lehet például hozzáadni egy értéket, csak az a nevű objektummal dolgozhatok. Lehet: Alkalmazott a, b; -- Változók, de nincs értékük, -- vagy null értékűek (ha adattagok). a = new Alkalmazott(); b = a; -- a cím átmásolását jeleni, -- nincs új terület foglalás -- az a és b ugyanazt az obektumot hivatkozza a.fizetes=50000; Ha valamely osztály definícióban ilyen adattagot definiálok, megtehetem: final Alkalmazott a=new Alkalmazott(); ami annyit jelent, hogy definiáltam egy a nevű referencia típusú változót, amely mindig ugyanarra az alkalmazottra mutat (amely tetszés szerint változtathatja az állapotát), és nem címezhet más objektumot. A JVM minden példány vonatkozásában tartalmaz egy referenciaszámlálót, amelyet a JVM az objektum létrejöttekor rendeli hozzá az objektumhoz. Ez a referenciaszámláló (mely megmutatja, hogy hány változó címzi az objektumot) nő, ha hivatkozok egy példányra, és ha megszüntetek egy hivatkozást, csökken. Erre épít egy

29 garbage collection-t (szemétgyűjtögetés). Ha a referenciaszámláló értéke 0, akkor az adott példány törölhető, a rendszer fölszabadítja a helyét. Automatikus. a = null; bármikor lehet. Ez megszünteti a referenciát. Nem kell explicit módon felszabadítani egy fölöslegessé vált objektum területét. Statikus tagok Statikus adattagok Alakja: static int nyugdijkorhatar = 65; Osztálynévvel minősíthető: Alkalmazott.nyugdijKorhatar; Statikus módszerek Például: static void nyugdijkorhataremel(){ } nyugdijkorhatar++; Osztálymódszereknél nincs példány. Főprogram A program indításakor egy osztálynevet kell megadni, amelyben van egy main nevű eljárás a következő specifikációval: public static void main (string args[]) A virtuális gép ennek adja át először a vezérlést. A specifikáció kötött Paramétere egy tömb, amely az indításkor megadott argumentumokat tartalmazza. Ezek megadása, szerepe rendszerfüggő.

30 A program befejeződik, ha: Ez befejeződik vagy Ha a programon belül meghívjuk a System osztály exit módszerét. Ha egy osztály definíciójánál nem adunk meg szuperosztályt, akkor automatikusan az Object osztály alosztálya lesz. Ez az osztály a hierarchia gyökere a Javaban.

31 Példa: class Factorial{ public static void main(string[] args){ int factorial = 1; int i = 1; while(i < 10){ factorial = factorial * i; System.out.println(i +!= + factorial + ); i++; } System.out.println(); } } A this és a super pszeudóváltozó Egy módszer törzsében használható a this és a super pszeudóváltozó. Ezzel hivatkozhatunk egy módszer törzsében a megfelelő aktuális példányra, illetve a megfelelő szuperpéldányra. boolean kevesebbetkeresmint (Alkalmazott masik ){ return masik.tobbetkeresmint(this); } A this és a super szavak túlterheltek a Javaban. Módszerek túlterhelése A módszernevek túlterhelhetők a Javaban, azaz több módszert ugyanazzal a névvel nevezhetünk meg, ha a formális paraméterek száma vagy a sorrendi kötés értelmében a típusa eltérő. Ekkor a módszer meghívásakor a megfelelő kódot a fordító az aktuális paraméterek száma és típusa alapján választja ki. A paraméterkiértékeléskor derül ki, hogy melyik a meghívandó kód. Ld. Factorial példánál a println() módszer esetén.

32 Polimorfizmus Egy örökölt példánymódszer implementációja tetszés szerint megváltoztatható. Az újraimplementált módszernek felülről kompatibilisnek kell lennie az örökölt módszerhez, azaz: Specifikációjuk megegyezik. Az újraimplementált módszerek csak azokat a kivételeket válthatják ki, mint az örökölt módszer. A bezárást csak enyhíteni lehet, szűkíteni nem: pl. protected public lehetséges, de fordítva nem. A Java a dinamikus (késői) kötés elvét vallja, nem kell külön előírni, mint a C++-ban. (Nem kell virtual!) Egy módszer meghívásakor egy módszer nevéhez mindig az aktuális példány osztályában definiált, vagy a legközelebbi örökölt kód fog meghívódni. Ezzel szemben az osztálymódszerek statikusan kötnek, osztálymódszereket nem lehet átdefiniálni. (Egy osztályhierarchia van, és az újradefinálással ezt a hierarchiát rúgnánk szét.) Adattagok elrejtése Az összes tag örökődik. A Java tiltja, hogy bizonyos tagokat elhagyjunk az öröklődés során. Viszont bevezeti az elrejtés (elfedés) fogalmát. Jelentése: az öröklődés során a leszármazott újraimplementálhatja a módszereket, és átdefiniálhatja az adattagokat, új tagokat definiálhat, de megszüntetni nem szüntetheti meg az örököltetett. Ezzel elrejti az eredetieket a hozzáféréstől az adott és az innen leszármazott osztályokban. Konstruktorok Amikor példányosítunk, a példány alapállapotát be kell állítani, ezt megtehetjük paraméterek segítségével. Ezt a célt szolgálják a konstruktorok (a konstruktorok tehát az alapállapot definícióját segítik elő), amelyek típus nélküli, az osztály nevével azonos nevű módszerek, amelyek láthatóságát szabályozhatjuk csak. A konstruktorok a példányosításnál automatikusan meghívódnak, és inicializálják azt. Az adattagoknak lehet kezdőértéket adni explicit módon, ha nem, akkor a rendszer inicializál. A programozó egy osztályhoz tetszőleges számú konstruktort írhat, és ezek neve túlterhelhető (a pataméterek száma és/vagy típusa különböző kell legyen). Kostruktor kizárólag a new operátor mellett hívható meg. A konstruktorok nem örökölhetők.

33 A konstruktor törzsének első utasítása lehet egy adott osztálybeli, vagy egy szülőosztálybeli másik konstruktor meghívása a következő szintakszissal: this(); illetve super(); A programozó nem köteles megadni konstruktort. Ha a programozó nem ad meg konstruktort, akkor a rendszer automatikusan felépít egyet, méghozzá olyat, amely paraméter nélküli és a törzse üres. Példa: public class Alkalmazott{... public Alkalmazott(String egynev, int egyfizetes){ nev=egynev; fizetes=egyfizetes evesfizetes=12*fizetes; } public Alkalmazott(String egynev){ nev=egynev; fizetes=30000; evesfizetes=12*fizetes; }... } Két konstruktort definiáltam. Egyiknek egy paramétere van, a másiknak kettő. Ez alapján tudja a rendszer eldönteni, hogy aktuálisan melyiket hívjuk meg. Említettük, hogy minden konstruktor törzsének első utasítása lehet egy másik osztályhoz tartozó konstruktor meghívása. Ebben az esetben átírható a következő módon: public class Alkalmazott{... public Alkalmazott(String egynev, int egyfizetes) { nev = egynev; fizetes = egyfizetes; evesfizetes = 12 * fizetes; } public Alkalmazott(string egynev){ this(egynev,30000); }... }

34 A szuperosztály konstruktorai nem öröklődnek, azokat mindig minden osztályhoz meg kell adni (vagy implicit). Viszont minden alosztály bármely konstruktora törzsének első utasításaként a super kulcsszóval meghívható a szuperosztály valamelyik konstruktora. (Például új adattagokat definiáltunk, de az átvetteket ugyanígy kell inicializálni.) A konstruktorok aktuális paramétereit példányosításnál a new operátor paramétereiként kell megadni a következőképpen: new konstruktor_név(aktuális_paraméter_lista); Alkalmazott a = new Alkalmazott("Ó Pál "); Alkalmazott b = new Alkalmazott("Jó Jenő, 55555); A Java lehetővé teszi, hogy osztály-konstruktorokat definiáljunk, az osztály definíción belül akárhol, tetszőleges számút. Ezek lényegében blokkok, amelyek előtt ott áll a static kulcsszó. Ezek az ún. statikus-konstruktorok (statikus inicializátorok). Definiálom az osztályt, a konstruktorokat. Amikor az osztályt először használom fel típusként, a rendszer végrehajt egy osztály inicializálást, melynek során automatikusan lefutnak az osztály-konstruktorok, abban a sorrendben, ahogy felsoroltam őket. A finalize() módszer Az osztályokkal kapcsolatos fogalomrendszert azzal zárjuk, hogy az Object osztályban létezik olyan módszer, amelynek finalize() a neve (protected és void). A finalize() olyan módszer, amelyet minden osztály örököl és átdefiniálhat. Minden osztály implementálhatja. Amikor egy objektum felszabadulásra kerül (azaz az objektum megsemmisítésekor), a tényleges felszabadítás előtt lefut ez a módszer: "Az adott példány egy utolsó kívánsága. " Meghívása automatikus. Létezik ennek egy osztály szintű változata is (osztálymódszer): classfinalize() Abszolút platform függő. Ez az osztálymódszer az osztály megszünésekor automatikusan lefut. Mit jelent az, hogy megszünik egy osztály?

35 Interfészek Speciálisan JAVA eszköz. Az interfész egy speciális referenciatípus, amely konstans adatttagokat és módszer specifikációkat tartalmaz. Az interfész nem objektum. A célja az absztrakciós szint növelése. Úgy tudunk problémát megoldani, hogy az implementációt nem adjuk meg. Programfejlesztés közben behozok egy absztrakciós szintet, amikor a specifikációval foglalkozom, és az implementációval nem. Az interfészek között is értelmezhető az öröklődés, méghozzá többszörös. Közös ősinterfész nincs, tehát a programfejlesztés folyamán interfész hierarchia-gráfok építhetők fel. Az interfészek implementációját mindig egy osztály végzi teljes mértékben. Az interfészt teljes mértékben implementálnia kell az osztálynak. Tehát az interfész hierarchia alján mindig osztályok állnak. Egy osztály tetszőleges számú interfészt implementálhat. Az interfészek által jelenik meg a többszörös implicit öröklődés a Javaban. Az interfész, mint referencia típus mindenütt szerepelhet, ahol az osztály, mint típus szerepelhet. Lehet vele változókat, tagokat definiálni, és formális paramétereket leírni. Az így definiált eszköz egy olyan referenciát kaphat értékül, amelynek a típusa egy olyan osztály, amely az adott interfészt közvetve vagy közvetlenül implementálja. Múltkori példánkban eljárhattunk volna úgy, hogy az egyes osztályokat, mint interfészeket definiáljuk, és az Ellipszis interfészt implementálja közvetlenül a Kör osztály, és a Zárt alakzat és az Alakzat interfészeket közvetve. Példa: Alakzat Nyílt Zárt Poligon Ellipszis Kör Az interfész definíciója: módosító INTERFACE név [ EXTENDS szuperinterfész_nevek ] törzs Az interfész módosító ja csak public lehet.

36 A törzsben: az adattagok módosítói alapértelmezés szerint: public static final Nem írandók ki, és nem változtathatóak. Konstans adattagokról van szó, tehát a kezdőérték adás kötelező. a módszereknek csak a specifikációjuk szerepel A módosítók: public abstract. Nem kiírandók, és nem kiírhatók. A többszörös öröklődésből származó névütközéseket a Java nem kezeli. Interfészek implementálása : módosító CLASS név IMPLEMENTS interfész_nevek törzs Az összes absztrakt módszert implementálni kell. Nagyon kemény absztrakciós eszköz és nagyon jól használható. Csomag Abban az értelemben, ahogy az Adában. A csomagok tartalmazzák a Java fejlesztői környezetet és az alkalmazásokat is csomagokban írjuk meg. A csomag egy hatásköri egység. Fordítási egység a Javaban: osztály deklaráció vagy interfész deklaráció vagy ezek tetszőleges együttese. Az osztályokat és az interfészeket együttesen hívja a Java típusnak. Tehát fordítási egységek a típusdeklarációk és ezek tetszőleges együttese. A fordítási egység mögötti kód mindig kötelező módon csomagokban jelenik meg. A csomagok között hierarchia építhető föl (könyvtárszerkezet). A Java rendszer tehát csomagfák (csomagok alkotta fák) együttese, melyek tartalmazzák a fejlesztői környezetet és az alkalmazásokat is. A csomag tartalmazhat alcsomagokat és típusdeklarációkat tetszőleges mélységben. Megnevezés: névvel. Hivatkozás: minősítéssel. Egyrészt a csomagfán belüli csomagra, másrészt csomagon belül: típus objektum tag.

37 Egy fordítási egység teljes szerkezete: [CSOMAGLEÍRÁS][IMPORTLEÍRÁS][TÍPUSDEKLARÁCIÓK] csomagleírás: PACKAGE csomagnév ; A megadott nevű csomaghoz fog tartozni a lefordított kód. Ha nem szerepel, akkor a Java rendszer egy név nélküli csomagba tartozónak tekinti (ebbe most nem megyünk bele). A név nélküli csomagok kezelése rendszerfüggő. Nem javallott, hogy név nélküli csomagokat használjunk, a hordozhatóság sérülhet. Általában igaz, hogy egy név nélküli csomag van. importleírás: import minősített_név ; Gyakorlati eszköz. Az Ada környezet leírásának felel meg. Arra szolgál, hogy más csomagokban deklarált nyilvános típusok itteni használatát segítse elő úgy, hogy egyszerű és ne minősített névvel kelljen rájuk hivatkozni. Példa: import Alakzat.Zart.Ellipszis.Kor ; És ezután elég a Kor hivatkozás, de akkor ennek egyedinek kell lennie. Megengedett az: import Alakzat.Zart.Ellipszis.*; ekkor az összes publikus típust eléri a nem minősítet neve alapján. típusdeklarációk: itt osztály definíciók állnak. A Java alapcsomagjai a java csomagban vannak. Ennek alcsomagjai: java.lang java.io java.util java.sql java.net java.applet java.awt java.awt.event A java.lang tartalmazza a legalapvetőbb eszközöket, ennek minden nyilvános típusa automatikusan importálódik, nem kell külön megadni. Ebben van például az Object osztály, a primitív típusok, stb. Az összes többi tagot importálnom kell.

38 Kivételkezelés a Javaban Adaszerű elveket vall. Ez is alapvető eszköze a Javanak. Ipari szabványszerű. A Java program működése közben módszerek hívódnak meg. Ha bekövetkezik egy speciális esemény egy módszer futása közben, akkor egy kivétel-objektum jön létre: vannak kivétel-osztályok és annak kivétel-példányai. Ekkor a módszer eldobja a kivételt, és a kivétel a Java virtuális gép hatáskörébe kerül át. Az adott módszer befejezi a futását annál az utasításnál, ahol a kivétel bekövetkezett, és jön a kivételkezelés. A JVM feladata, hogy megkeressen egy adott objektumnak megfelelő típusú, az adott pontba látható kivételkezelőt, amely kivételkezelő az adott kivételt elkapja. Egy kivételkezelő megfelelő típusú, ha: a kivételkezelő típusa megegyezik a kivétel típusával a kivételkezelő típusa őse a kivétel típusának. A láthatóságot maga a kivételkezelő definiálja. Maga a kivételkezelő egy blokk. Az Adában kivételkezelő fordítási egység végén helyezhető el, ezzel szemben a Javában tetszőleges kódrészlethez köthető. Ezek a kivételkezelők tetszőleges mélységben egymásba ágyazhatók. Ha van egy kivételkezelő, amely nem kezel minden kivételt, kérdés: hogyan tovább? A kivételkezelőblokkon lépked kifelé a JVM az Ada illetve a PL/1 filozófiája szerint dinamikusan, amíg nem talál megfelelő kivételkezelőt. Egy blokk végső soron egy módszer törzse. Ha nincs ott kezelve a kivétel, akkor a JVM továbbadja a kivételt a hívási láncon a hívónak. Ha talált megfelelő típusú kivételkezelőt a JVM, átadja annak a vezérlést, a kivételkezelő lefut, és a program folytatódik a kivételkezelő kódját követő utasításon. A kivételkezelőben bekövetkezett kivételeket ugyanígy kezeli a JVM, mint bárhol máshol. A kivételek két csoportjáról beszél a Java: ellenőrzött nem ellenőrzött kivételek Elengedi az ellenőrzést olyan eseményeknél, amelyek bárhol bekövetkezhetnek, ellenőrzése vagy nagyon kényelmetlen vagy lehetetlen, irreálisan nagy kódtöbbletet eredményezne, vagy a programozó ezekkel a kivételekkel nem tud mit kezdeni. Ez utóbbi kivételek tartoznak a nem ellenőrzött kivételek közé. Javallott, hogy használjunk ellenőrzött kivételeket. Az ellenőrzött kivételeket, amely egy metódus láthatósági körében felléphet, a programozónak mindig specifikálnia kell, vagy el kell kapnia őket. Ezt a fordító vizsgálja, és hibát jelez, ha ez nem teljesül. Biztonságos kódot kell írni! Egy módszer fejében tehát meg kell adni azokat az ellenőrzött kivételeket kivételeket, melyeket a módszer nem kezel, de futás közben bekövetkezhetnek.

39 Ennek specifikálása a módszer fejének végén: THROWS kivételnév_lista utasításrész segítségével történik. Itt soroljuk fel, tehát a módszer láthatósági körében keletkezett, ellenőrzött, de nem kezelt kivételeket. A kivételek kezeléséhez a java.lang csomagban definiált ősosztály a Throwable objektumai dobhatók el (miután a kivétel is objektum). Az eldobás a THROW utasítás segítségével történik. Két standard alosztálya van: Error : ide tartoznak a rendszerhibák, ezek nem ellenőrzöttek. Exception : ellenőrzött kivételek osztálya. Ebből az osztályból származtathat a programozó saját ellenőrzött kivételeket. Természetesen a Java csomagjaiban számos leszármazottja van (standard kivételek). A throw utasítás alakja (a kivétel-osztály példányosítása): THROW NEW_OPERÁTOR; Ez kivált egy megfelelő típusú kivétel objektumot, és eldobja a kivételt, átadja a JVM-nek.

40 Példa: Saját kivétel definiálása és kivételkezelés: class VeremMegteltException extends Exception{ Object utolso; public VeremMegteltException( Object o){ utolsó = o; } public Object nemfertbele(){ -- ezzel érjük el a tetejét return utolso; } } class Verem{ final static public int Meret = 100; Object tarolo[]; int mutato = 0; : public void push (Object o){... if ( mutato!= Meret ){ tarolo[mutato++] = o; } else{ throw new VeremMegteltException(o); --példányosítás }... }... } A kivételkezelő szerkezete a Javaban: TRY { Utasítások } -- ellenőrzött kivételek, amelyek látják a kivételkezelőt CATCH (típus változónév ) {Utasítások} [CATCH ( típus változónév){ Utasítások}]... [FINALLY { Utasítások}]

41 A TRY blokkban elhelyezett utasításokban keletkezett kivételek esetén a JVM a CATCH utasításoknak adja át a vezérlést. Ha ott talál megfelelő típusú ágat, lefutnak a blokkbeli utasítások, és végrehajtódnak a FINALLY utáni utasítások, és a program folytatódik a FINALLY után. Ha nincs egyetlen megfelelő kivételkezelő sem, és van FINALLY ág, lefutnak az utasításai, és a kivétel az adott kódrészt (TRY) meghívó módszerhez kerül, vagy beágyazott blokk esetén a tartalmazó blokkhoz. A FINALLY ág akkor is lefut, ha nem volt kivétel! A CATCH ág teljesen hiányozhat. A típusegyeztetés miatt a felírás sorrendje nagyon lényeges, ugyanis a CATCH ág az ellenőrzött kivételt elkapja. A hierarchiában lentről fölfele kell elkapni. Módosítsuk ezek alapján a kódot: class Verem{ final static public int Meret = 100; Object tarolo[]; int mutato = 0; : public void push (Object o){... try{ if ( mutato!= Meret ){ tarolo[mutato++] = o; } else { throw new VeremMegteltException(o); }... } /*try*/ catch(veremmegteltexception e){ System.out.println( A(z) +e.nemfertbele()+ obektum nem fért el a veremben! ); } catch(exception e){ System.out.println( Hiba! Hívja a rendszergazdát! ); } finally {System.out.println( A push lefutott. ); }... }

42 SZÁLAK A párhuzamos programozás eszközei a Javában a szálak. A szálak objektumok, a Thread osztályból származnak. Ezek run() módszere adja a futtatandó kódot. A Runnable interfészt implementáló osztállyal is megadhatunk szálakat. Ebben a run() módszert is implementálni kell. Itt is ez adja a kódot. A Thread osztály a Runnable egy implementációja. A szálak a Javaban a következő állapotban lehetnek: új futtatásra kész fut várakozik halott Új szálat (mint objektumot) a new operátorral hozunk létre, ekkor csak létrejön. Él a szál, de semmi több, semmi aktivitást nem mutat. Futásra kész állapotba hozni a start() módszerrel lehet. A futásra kész állapot annyit jelent, hogy beáll a sorba. A Java rendszerek általában egyprocesszorosak. A futásra kész szálak közül az ütemező választja ki a futtatandó szálat. Az egyprocesszoros rendszerek indeterminisztikusak! A kiválasztott szál működni kezd, fut (a run() módszer indul el). Egy szál halott állapotú lesz, ha meghívjuk a stop() módszerét, vagy a run() módszer kódja elfogy. Nem lehet egy halott szálat újra elindítani. A várakozás a szinkronizáció eszköze a Javában. A szálak szinkroniációja meglehetősen sokszinű. A szinkronizációra a Hoare-féle monitort alkalmazza a Java. Ezzel kapcsolatban a következő eszközök állnak rendelkezésre: Egy szál a következő esetekben kerülhet várakozó állapotba: a sleep(x) módszer meghívásával, a paraméter ezredmásodpercben értendő. Hatásra az adott szál adott ideig várakozik. a wait() módszer meghívásával. Szintén várakozást tudunk előidézni. a suspend() módszer felfüggeszti a szál futását I/O művelet befejezésére vár Várakozó szál a következőképpen kerülhet futásra kész állapotba: sleep() esetén továbbmegy a szál az idő letelte után. wait() esetén notify() vagy notifyall() módszer meghívásával megszűnik a várakozás suspend() módszer esetén a resume() módszerrel újraindul a futás ha befejeződött az I/O művelet