OOP 2010 Tételek kidolgozva by NagyImre

Kidolgozta: Nagy Imre oldal 1

OOP tételek

1. Az objektum orientált programozás szemlélete, az objektum fogalma.

Az objektum orientált programozás (OOP) szemlélete

Az analízis modell elkészítése során a valóságot objektumok halmazaként tekintjük. Ezen objektumok

egymással kapcsolatban vannak és együttműködnek.

A természetes objektumok jellemzői

- egyéniség (különállás),

- struktúra (adatok),

- viselkedés (más objektumokkal való kapcsolata),

- állapot (adatainak aktuális értéke).

Az objektum: egyediséggel rendelkező diszkrét entitás.

Jellemzői: attribútumok, műveletek.

- attribútum együttes: objektum állapot, ennek időbeli változása az objektum viselkedése,

- műveletek (operations): ezek modellezik az objektum viselkedését.

Objektumtól objektumig

1. szint

- Tanulmányozzuk a valós objektumokat, és megkeressük azoknak a probléma megoldása szempontjából

fontos adatait és viselkedésmintáit. (Az absztrakció definíciójából a "leglényegesebb tulajdonságok

kiemelése".) - Ezután megkeressük azon objektumcsoportokat, amelyek azonos adatokkal és viselkedésmintákkal

rendelkeznek, és elnevezzük ezt a csoportot. (Az absztrakció definíciójából az "általánosítás".)

2. szint

- Az előzőleg definiált fogalom leképezése egy programozási eszközre (osztálydefiníció elkészítése). Ez

valójában egy minta a program működéséhez szükséges objektumok létrehozására.

3. szint

- Akkor és annyi objektumot kell létrehozni a program futása során, amelyek együttműködve képesek a

valóságot modellezni.

Az objektum orientált program

Egymással kommunikáló objektumok halmaza.

Működés: üzenetváltások.

Struktúra: osztályok és objektumok közötti kapcsolatok.


Az objektum orientált programkészítés folyamata

- a probléma leírásában keressük az objektumokat,

- objektum csoportok közös tulajdonságait osztályokkal írjuk le,

- megkeressük az osztályok kapcsolatait,

- az osztályokat és kapcsolataikat implementáljuk egy programozási eszközzel,

- létrehozzuk a megfelelő példányokat (objektumokat) a megfelelő időben, és megoldjuk a

kommunikációjukat.

Az implementációhoz általában szükségünk van az eredeti probléma objektumain túl technikai szerepű

osztályokra / objektumokra is, például - adatszerkezetek kezelésére (tömb, stb)

- vezérlési feladatok megoldására

- megjelenítési feladatok megoldására

- stb.

2. Az objektum orientált programozás alapelvei.

Az objektum orientált programozás alapelvei

1. Osztály (class)

2. Objektum (object) 3. Egységbezárás (encapsulation)

4. Információ rejtés (information hiding)

5. Üzenet (message)

6. Öröklődés (inheritance)

7. Polimorfizmus (polymorphism)

Osztály:

Részei:

- adatok (az attribútumok modellezésére),

- módszerek (a műveletek modellezésére).

Objektumok közös tulajdonságait definiálja.

Programozás technikai szempontból egy típus.

Objektum:

Egy osztály egy működőképes példánya.

Egy adott osztályban definiált tulajdonságokkal tetszőleges számú objektum példányosítható.

Minden objektum természeténél fogva különbözik az összes többitől. Egy adott osztályból példányosított valamennyi objektumnak ugyanolyan lehetséges viselkedés módjai

(műveletei) vannak, de saját állapotuk van.

Egységbezárás:

Az osztály az adatait és a módszereket egy egységgé teszi.

- az adatok és a módszerek lokálisak,

- a módszerek hozzáférhetnek az adatokhoz.

Információ rejtés:

Egy objektum adatai a külvilág (más objektumok) számára hozzáférhetetlenek.

Egy objektum a külvilággal csak az interface-én keresztül tarthatja a kapcsolatot.

Interface: a külvilág számára elérhető módszerek együttese.

A módszerek implementációja rejtett.

Üzenet:

Az objektummal való kommunikáció módja.

A módszerek aktivizálását (invocation) jelenti.

Öröklődés:

Hierarchikus kapcsolat(rendszer).

A leszármazott osztály örökli az ősosztály adatait és módszereit.

Az örökölt módszereket felüldefiniálhatja a maga számára.


Új (saját, csak rá jellemző) adatokat és módszereket definiálhat.

Egy leszármazott osztály csak bővítheti, pontosíthatja az őst, de nem utasíthat el örökölt adatokat vagy

módszereket.

Polimorfizmus:

Jelentése: többalakúság.

Bizonyos elemek viselkedése attól a környezettől függ, amelyben alkalmazzuk.

A gyakorlatban ez azt jelenti, hogy egy nyelvi elem (például egy kódrészlet) attól függően, hogy hol

alkalmazzuk, más-más működést eredményezhet.

3. A Java nyelv története, alapvető tulajdonságai.

Egy kis történelem

- 1990-es évek eleje:

A SUN belső project-je James Gosling vezetésével (set top box) platform-független technológia

szükségessége.

Egyik akkori nyelv sem volt megfelelő, ezért terveztek egy újat.

A projekt (és vele az új nyelv) aztán lassan elhalt.

- 1990-es évek közepe:

Az Internet rohamos terjedése újra felvetette a platform-független technológia szükségességét.

Újraéledt a project, de általánosabb célkitűzéssel.

Eredménye a Java nyelv első verziója lett.

- 1995: Java 1 platform

- 1999: Java 2 platform (1.2-es verziószámtól)

Jelenleg: (2007. február): J2SE 1.6 (Java 6 platform)

A Java egyszerre

- programozási nyelv és

- platform.

A Java nyelv alapvető tulajdonságai

- magas szintű programozási nyelv,

- platform-független,

- általános célú,

- teljesen objektum-orientált,

- egyszerű,

- interpretált (de speciális módon),

- elosztott (distributed),

- robosztus,

- biztonságos,

- hordozható,

- többszálú (multithreaded),

- A C++ ismeretében született, annak formalizmusát tekintette mintának,

- A C++ hátrányait igyekezett kiküszöbölni.

A Java nyelv egyszerű

C / C++ szerű nyelv, de nem vette át azokat a nyelvi elemeket, amelyek veszélyes konstrukciókat engednek meg.

Legfontosabb egyszerűsítés a pointerek "száműzése".

A Java nyelv könnyen megtanulható. Ez nem jelenti azt, hogy jó Java programok írása is könnyű feladat!

Nagyon nagyméretű standard könyvtár készlet! Ez hatékonyabbá teszi a programozást, de nehezíti a

megtanulást.

A Java egyszerre fordított és interpretált


A Java mint platform

A Java egy tisztán software megvalósítású platform is.

Két része van:

- a Java virtuális gép (JVM),

- a Java programozási interface (Java API).

A Java szabványok

A SUN az alábbi részekre (kiadásokra) osztja a Java alapú szabványos eszközöket:

- J2SE - Java 2 Plattform, Standard Edition,

- J2EE- Java 2 Plattform, Enterprise Edition,

- J2ME- Java 2 Plattform, Micro Edition.


J2SE

J2SE- Java 2 Plattform, Standard Edition

Mindazon alapszolgáltatások, amelyek Java programok készítését teszik lehetővé.

Legfontosabb részei:

- maga a Java nyelv,

- alapvető hálózati szolgáltatások,

- RMI,

- applet és a szervlet,

- lokális komponensek (JavaBeans),

- GUI (platformfüggetlen felhasználói interface elemek),

- ...

J2EE

J2EE- Java 2 Plattform, Enterprise Edition

A J2SE szolgáltatásait is tartalmazza, ezen felül a legfontosabb részei:

- komponens szemléletű fejlesztés, - a nagyméretű alkalmazások készítését támogatja,

- Web szolgáltatás alapú alkalmazások készítése,

- biztonságos, robosztus rendszerek fejlesztésének eszközei.

J2ME

J2ME- Java 2 Plattform, Micro Edition

Kis erőforrásokkal rendelkező rendszerekre optimalizált.

Smart card-ok, vezeték nélküli eszközök, beágyazott rendszerek stb. fejlesztéséhez.

4. Mi kell egy Java program fejlesztéséhez, illetve kész program futtatásához?

Java alapú fejlesztés

Valamennyi Java szabvány, és a SUN által implementált alapvető fejlesztőeszközök nyílt forrásúak és

ingyenesek.

Ezen kívül számtalan:

- nyílt forrású, ingyenes,

- zárt forrású, de ingyenes,

- kereskedelmi termék.

A minimális fejlesztőkörnyezet

A J2SE szolgáltatásaihoz:

- J2SDK vagy újabban JDK ("Java Development Kit).

A java.sun.com oldalról ingyen letölthető számtalan platformra.

A legfrissebb verzió: JDK 6.0 (2007. február).

- egy tetszőleges szövegszerkesztő.

Kényelmesebb fejlesztői környezetek

Ingyenes integrált fejlesztőeszközök például:

- NetBeans

Letölthető a java.sun.com címről.

- Eclipse

Letölthető a www.eclipse.org címről.

Mindkét fejlesztőeszköz maga is Java-ban íródott, tehát sokféle platformon futtatható (Pl. Windows, Linux).

A JDK legfontosabb elemei

- A Java API-t implementáló könyvtárak,

- segédprogramok: - javac: java fordító,

- java: a JVM (futtatáshoz),

- javadoc: automatikus dokumentáció generáláshoz a forrás szöveg és a benne található speciális

kommentek

alapján,


- jdb: debugger,

- stb.

A minimális futtató környezet

A J2SE szolgáltatásaihoz:

- JRE (Java Runtime Environment).

A java.sun.com címről letölthető számtalan platformra.

A JDK tartalmazza.

Ha egy gépen csak JRE van, bármely más gépen fejlesztett Java program futtatható, ha ugyanolyan, vagy

korábbi verziójú JDK segítségével készült.

5. A Java program (alkalmazás), a Java applet és a JavaScript fogalma.

A Java program

Java program: Java-fordítóval készült önálló alkalmazás.

Az adott architektúrán futó JVM hajtja végre.

Mindazon jogokkal rendelkezik, mint bármely más alkalmazás.

A Java applet

Applet: HTML oldalból elérhető, végrehajtható byte kód, ami Java forrásból készült.

A HTML kódba csak egy hivatkozás kerül, az applet maga (a lefordított kód) bárhonnan letöltődhet.

A HTML oldal értelmezője (a böngésző) hajtja végre (a böngésző valósítja meg a JVM-et).

Korlátozott jogokkal rendelkezik biztonsági okok miatt.

És egy névrokon: a JavaScript

Eredetileg LiveScript néven a Netscape-nél kifejlesztett script nyelv (tehát nem bináris kód).

Célja web oldalak dinamikussá tétele.

A (szöveges) kód része a html oldalnak.

A Java-hoz hasonlóan a C++ szintakszisához hasonló formalizmus.

Nem objektum orientált, csak objektum alapú (nem implementálja valamennyi alapelvet).

Bár ezt is a böngésző értelmezi, semmi köze a Java platformhoz (nem a JVM értelmezi).

6. A Java alapelemei: karakterkészlet, azonosító, megjegyzés, egyszerű típusok.

A Java formalizmusa

A C, illetve az annak bővítéseként definiált C++ szintaktikájával nagyon rokon.

A Java program

A Java program osztályok halmaza.

Végrehajtható kód csak osztály metódusában fordulhat elő.

Egy alkalmazás belépési pontja egy olyan osztály, amelyben van egy public static minősítésű main nevű

metódus

(ez teszi futtathatóvá a programot).

Azonosítók

A Java a Unicode karakterkészletet használja, tehát akár ékezetes azonosítókat is használhatunk. Az azonosító

- betűvel kezdődő és betűvel vagy számmal folytatódó karaktersorozat,

- az _ és a $ is a betűk közé sorolandó,

- a betűk bármelyik karakterkészletből származhatnak,

- hossza tetszőleges,

- a JAVA is kis- és nagybetű érzékeny (case sensitive),

- kulcsszavak, valamint a const, goto, null, true, false szavak nem lehetnek azonosítók.

Megjegyzések

Mint a C-ben: /* Szöveg */

Egysoros: // Innentől a sor végéig komment


Dokumentációs (a javadoc segédprogram feldolgozza): /** Tetszőleges szöveg*/

Egyszerű típusok

Hasonlóak, mint C-ben, de pontosan definiált helyfoglalással és ábrázolási móddal.

Nincs unsigned minősítő.

Konstans változó final minősítővel deklarálható (a const helyett).

Elemi típusok fedő osztályai

Minden egyszerű típusra létezik neki megfelelő osztály, ezek segítségével egyszerű típusú értékek is

használhatók ott, ahol objektumra van szükség.

Fedő osztályok: Byte, Short, Integer, Long, Float, Double, Character, Boolean, Void (a java.lang

csomagban definiáltak).

Előre definiált konstansok a fedőosztályokban

Byte, Short, Integer, Long :

- MIN_VALUE, MAX_VALUE: a legkisebb és a legnagyobb ábrázolható szám

Float, Double :

- MIN_VALUE, MAX_VALUE: a legkisebb és a legnagyobb ábrázolható abszolút értékű szám

- NaN: nem szám (számként nem értelmezhető)

POSITIVE_INFINITY, NEGATIV_INFINITY: a pozitív, és a negatív végtelent jelentik

7. A Java alapelemei: lokális változó, tömb, vezérlő utasítások.

Literálok (konstansok)

Logikai értékek: true vagy false.

A C-vel teljesen egyező módon használandók:

- egész konstans,

- lebegőpontos konstans,

- karakter konstans (az escape szekvenciák is!),

- szöveg konstans (csak Unicode szöveget is tartalmazhat) (a fordító automatikusan String típusúként

kezeli).

Lokális változó használata

Definíciója csak metóduson belül.

Nincs globális változó!

Formája, mint a C-ben, beleértve a kezdő értékadást is.

Egyszerű típusú lokális változó definíciója egyben helyfoglalást is jelent.

Különbségek:

- változó definíció egy metóduson belül bárhol lehet (nem csak blokk elején),

- a változó csak a definíció után használható.

Egydimenziós tömb

Definíciója eltér a C szintaktikától.

Két lépés (amely egy utasításba összevonható):

1. Tömb típus deklarációja

típusnév azonosító[]; vagy típusnév [] azonosító;

2. Helyfoglalás a tömb elemeinek:

azonosító = new típusnév[elemek száma]


A két lépés egy utasításba összevonva:

típusnév azonosító [] = new típusnév[elemek száma]

Az elemekre való hivatkozás már ugyanaz, mint a C nyelvben.

A Java-ban többdimenziós tömbök is definiálhatók, amelyek nem feltétlenül „négyzetesek”.

Bár nincs előre definiált osztálya, de osztályhoz tartozóként kezeli a Java.

Minden tömbhöz tartozik egy length konstans, amely az elemek számát adja meg. Használata: azonosító.lenght

Az indexelés itt is 0-tól kezdődik. Különbség: az érvénytelen index kivételt vált ki!

Utasítás, blokk

Utasítás lehet:

- kifejezés utasítás,

- deklarációs utasítás.

Az utasításokat pontosvessző zárja. Kifejezés utasítás csak a következő lehet:

- értékadás,

- ++ és -- operátorokkal képzett kifejezések,

- metódushívás,

- példányosítás.

A deklarációs és kifejezés utasítások tetszőleges sorrendben követhetik egymást.

Az utasítások sorozata {} jelek közé zárva a blokk. (Utasítás helyére mindig írható blokk.)

Vezérlő utasítások

Lényegében megegyeznek a C utasításaival.

Különbségek:

- az if, while, do utasításokban a feltétel csak logikai kifejezés lehet,

- a for utasításban a második kifejezés csak logikai kifejezés lehet,

- a switch utasításban a szelektor csak egész kifejezés lehet,

nincs goto utasítás.

8. Osztálydefiníció, adattag, metódus fogalma. Példányosítás.

Osztálydefiníció

A Java program osztályok halmaza.

Egy osztálydefiníció egyben egy teljes fordítási egység (de általában nem teljes program).

Az osztály és a definícióját tartalmazó file neve meg kell egyezzen.

Osztályok csomagokba rendezhetők, ezzel lehet modulokat képezni.

Az osztálydefiníció fejlécből és {} zárójelpárral határolt törzsből áll.

A fejléc formája:

[módosító] class osztálynév [extends ősosztály] [implements Iint1[,Iint2[,…]]] {

[Elemek deklarációi]

} Az osztály neve egy azonosító.

A törzsben adattagok és metódusok (együttesen tagok) és további elemek definíciói állhatnak.

Adattagok

Definíciója:

[módosítók] típusnév azonosítólista;

A típusnév valamelyik egyszerű típus, tömb típus, vagy osztálynév lehet.

A névlista elemeit veszővel választjuk el, formájuk:

azonosító[=inicializáló kifejezés];

Az inicializáló kifejezésben csak előtte már deklarált adattagok használhatók.

Az inicializáló kifejezés minden példányosítás esetén kiértékelődik.

Nem inicializált adattag az alábbi (típustól függő) default értékkel inicializálódik:

- boolean: false,

- char: '\u0000' ,

- minden egész típus: 0 ,

- minden lebegőpontos típus: 0.0 ,


- osztály típus: null.

Metódusok

Hasonló a C függvény definíciójához. Formája:

[módosítók] típus név(paraméterlista)[…]

A módosítókat és a […] helyén álló elemet leszámítva a többi ugyanaz, mint a C-ben, kivéve a tömb

paramétereket (hiszen nincs pointer!).

Példányosítás

Az osztály objektumok létrehozásához használható mintaként tekinthető.

A Java programban az osztálynév típusként használható.

Az objektum létrehozásának folyamata a példányosítás.

Egy osztályból tetszőleges számú objektum példányosítható.

Ez a legegyszerűbb mód egy osztály típusú változó definiálása.

Formája:

[módosítók] osztálynév azonosító = new osztálynév([paraméterek])

A () zárójelpár a paraméterek hiányában is kötelező.

A folyamat:

- lefoglalódik az objektumnak szükséges hely,

- inicializálódik az objektum (a programozó befolyásolhatja az inicializálást), - a lefoglalt memóriaterületre való hivatkozás kerül a változóba.

9. Hivatkozás típusú változó (referencia) fogalma, az egyszerű típusú és az osztály

típusú változók közötti különbség. Hivatkozás az objektum elemeire.

Hivatkozás

A Java-ban kulcsfogalom.

Osztály típusú változó mindig hivatkozás, nem objektum!

Hivatkozás típusú változó:

- értéke cím, amely egy objektumot címez meg, (ebben hasonlít a pointerre) vagy null,

- használata indirekció nélkül magát az objektumot jelenti a kifejezésekben, - az értéke (a cím) a programozó számára hozzáférhetetlen (és szükségtelen is).

Következmény: objektum csak futás közben, dinamikusan (a new operátor használatával) hozható létre.

Hivatkozással végezhető műveletek:

- definíció,

- értékének beállítása objektum létrehozásával,

- értékadás hivatkozások között,

- értékének beállítása a null konstansra (sehová nem mutató hivatkozás),

- két hivatkozás összehasonlítása (a == művelettel),

- használható objektum elemére való hivatkozásban.

Egyszerű típusú és osztály típusú változó

Alapvető különbség!

- Egyszerű típusú változó: a deklarációja egyben definíció is, hely foglalódik a memóriában, és a

továbbiakban a változó az ott tárolt értéket képviseli.

- Osztálytípusú változó: deklarációja hatására csak egy cím számára foglalódik memória. Ezt a címet egy

példányosított objektum címére kell beállítani. Ezután a változó az általa hivatkozott objektumot fogja

képviselni.

Objektum elemeire való hivatkozás

- osztályon belül (mivel egy hatáskörben vannak): névvel, - minden más esetben az objektum (egyes esetekben az osztály) nevével minősítve, a . (pont) operátorral.

Metódusra való hivatkozásnál aktuális paramétereket is kell adni, és a hivatkozás a metódus aktivizálását

(meghívását) jelenti.

Az információrejtés alapelvének megvalósítása érdekében a Java korlátozza az objektumok tagjaira való

hivatkozást.


10. Hozzáférési kategóriák és jelentésük. Használatukra vonatkozó konvenciók.

Hozzáférési kategóriák

A [módosítók] szintaktikai elem egyik feladata a hozzáférési kategóriák megadása.

- osztály csak nyilvános vagy félnyilvános lehet,

- adattag és metódus bármelyik kategóriába tartozhat,

- metódusok nyilvánosak (tehát bármely más osztályból is elérhetők).

Hozzáférési kategóriák használata

Az információrejtés alapelvének betartása érdekében minden elem kapja a lehető legszűkebb kategóriát.

Szokásos konvenciók:

- egy osztály csak akkor legyen public, ha általános használatra szántuk, - az adattagok private (esetleg protected) minősítést kapjanak, ha szükséges, metódusokon keresztül

legyenek elérhetők (a public adattag hiba!),

- a metódusok közül csak a "külvilág" számára szükségesek (az osztály interface-ét jelentők) legyenek

public minősítésűek.

11. A this pszeudó változó és szerepe.

A this pszeudó változó

Minden objektumhoz - saját adattag-készlet tartozik,

- az osztály összes objektumára közös a tagfüggvény-készlet.

Kérdés: Hogyan tud a tagfüggvény az aktuális objektum adattagjaira hivatkozni?

Megoldás:

Minden objektumhoz létezik az előredefiniált this pszeudó változó, amely az adott objektumra hivatkozik.

Ezen keresztül éri el az adattagot a tagfüggvény.

A this pszeudó változó explicite is használható.

12. Metódusnév túlterhelés (overloading).

Metódusnevek túlterhelése (overloading)

Egy osztályhoz több metódus is tartozhat

- azonos névvel,

- de különböző paraméterszignatúrával.

Paraméterszignatúra: a formális paraméterek száma és típus-sorrendje.

Figyelem: a visszatérési érték típusa ebből a szempontból közömbös!

A polimorfizmus egyik implementációs formája ("környezet" = paraméter szignatúra) a korai kötés (early

binding): a függvény hívásakor a fordítóprogram az aktuális paraméterek szignatúráját sorban egyezteti az összes azonos

nevű definíció formális paramétereinek szignatúráival.

Ennek az egyeztetésnek az alábbi eredményei lehetnek:

- pontosan egy illeszkedőt talál: ilyenkor az ennek megfelelő függvény hívását fordítja be,

- egyetlen illeszkedőt sem talál: hibajelzést ad, - több egyformán illeszkedőt talál: hibajelzést ad.


13. Konstruktor fogalma, definíciójának és használatának szabályai. Az implicit

konstruktor.

Konstruktor

Egy objektum adattagjai a létrehozáskor a default értékekkel inicializálódnak. Ez nem mindig felel meg a

programozónak. Ezen változtathat egy megfelelő metódussal, mely a létrejött objektum adattagjait a szükséges értékre állítja be.

Ez a módszer azonban nem a legjobb.

A konstruktor egy automatikusan meghívóüdó kódrészlet („függvény”). A konstruktor majdnem olyan mint egy

metódus az alábbi korlátozásokkal:

- neve megegyezik az osztály nevével

- nem lehet visszatérési értéke! (void sem!!!)

- legfeljebb „üres” return utasítást tartalmazhat (de az sem kötelező)

- már létező objektumra nem hívható meg közvetlenül

- nem öröklődik

- módosító csak hozzáférést szabályozó kulcsszó lehet.

A konstruktor legtöbbször public minősítésű.

Példányosítás konstruktorral

Minden példányosítás esetén az alábbi folyamat zajlik le: - helyfoglalás az adattagoknak,

- az adattagok inicializálása (default értékkel, vagy az inicializáló kifejezésnek megfelelően),

- a konstruktor meghívódása a példányosításban megadott aktuális paraméterlistával.

A konstruktornak szóló paraméterek a példányosítás során az osztálynév után, () zárójelpárban, vesszővel

elválasztva adhatók meg.

Konstruktor: további szabályok

- a konstruktor felhasználhatja az osztályban deklarált valamennyi adattagot

(az adattagok kezdőértéke a konstruktor számára az előzetes inicializálásnak megfelelő lesz),

- a konstruktor az osztály bármely metódusát használhatja,

- a metódusnév túlterhelés szabályainak betartásával egy osztályban tetszőleges számú konstruktor

definiálható,

- a példányosítás utáni első metódushívás feltételezheti, hogy valamelyik konstruktor már lefutott

(Figyelem!

Hibát okozhat, ha a konstruktor olyan metódust hív meg, amely feltételezi valamelyik konstruktor lefutását!

Egy metódus nem tudja megállapítani, hogy melyik konstruktor inicializálta az objektumot.),

- Egy konstruktor első utasítása lehet ugyanazon osztály vagy az ősosztály egy másik konstruktorának

meghívása

- Másik konstruktor meghívása:

this(aktuális paraméterlista)

(az aktuális paraméterlista nem használhatja fel az adattagokat),

- Ősosztály konstruktorának meghívása:

super(aktuális paraméterlista)

Implicit konstruktor

Egy osztálynak mindig van legalább egy konstruktora.

Ha a programozó definiál legalább egy konstruktort, akkor azok lesznek a konstruktorok.

Ha a programozó egyet sem ír, akkor az osztályhoz a fordító hozzárendeli az implicit konstruktort. (default

constructor)

Ez public, paraméter nélküli és a törzse üres.


14. Objektumok megszűnése. A szemétgyűjtő mechanizmus. A finalize metódus.

Objektum megszűnése

A C programozási nyelvben a futás közben, dinamikusan lefoglalt memória területek helyes felszabadításáért a programozó felelős. Ez számos hiba forrása lehet.

A Java-ban csak dinamikusan lehet objektumot létrehozni, de nem kell - és nem is lehet - megszüntetni.

Az objektumok automatikus megszüntetése a szemétgyűjtő mechanizmus (garbage collector) feladata.

Szemétgyűjtő mechanizmus

- számon tartja, hogy egy objektumra hány referencia hivatkozik,

- ha már nincs érvényes referencia, az objektum haszontalanná válik,

- egy külön szálban futó szemétgyűjtő felszabadítja a felesleges objektumokhoz tartozó memória területet

(Hogy ez pontosan mikor történik meg, nem tudjuk.).

Egy objektumra hivatkozó referencia megszűnik, például ha

- megszűnik maga a változó,

- megváltozik a változó értéke,

- a változónak a null értéket adjuk.

A finalize metódus

Minden osztályhoz definiálható egy ilyen metódus:

protected void finalize() throws Throwable

A szemétgyűjtő hívja meg, még az objektum tárterületének megszüntetése előtt.

Feladata minden olyan mellékhatás megszüntetése, amelyet az objektum az élete során okozott.

15. Java csomagok és fordítási egységek. Minősített (teljes) hivatkozás. Az import

direktíva.

Modularitás a Java nyelvben

A Java-ban a programok tagolásának eszköze a csomag (package).

Összetartozó típusok (osztályok és intefészek) egysége.

Minden csomagnak saját névtere van.

Elkerülhetők az egyező típusnevekből adódó problémák.

A csomagok a hozzáférési kategóriák használatának eszközei.

Csomagszerkezet

A Java-ban a csomagokban lehetnek alcsomagok, a csomagszerkezet fastruktúrát alkot.

A csomag tartalmát a fordítási egységek adják meg. A fordítási egységekben találhatók a csomaghoz tartozó kódok, azaz típusok (osztályok és interface-ek)

definíciói.

Hivatkozások

A csomagokra hierarchikus szerkezetű azonosítóval hivatkozhatunk:

Az A csomag B alcsomagjában levő C alcsomag: A.B.C

Az egyes csomagokban található típusokra teljesen analóg módon hivatkozhatunk:

A fenti csomagban definiált T típus: A.B.C.T

Csomagok és fordítási egységek

Csomagok és fordítási egységek összerendelése:

- leképezés az operációs rendszer file-rendszerére,

- tárolás adatbázisban.

Az első megoldással foglalkozunk:

- a fordítási egységek file-ok .java kiterjesztéssel,

- a csomag-alcsomag nevek pedig katalógus nevek, amelyekből útvonal generálódik.

A fenti példában említett A.B.C csomag T típusának megkeresése a következőképpen történik:

- egy előre kijelölt katalógus A alkatalógusának B alkatalógusában levő C alkaltalógusban a Java fordító a T.java fájlt keresi,

- a lefordított byte-kódot ugyanoda T.class néven helyezi el.

A csomagszerkezetnek több kiinduló katalógusa is lehet.


A fordító (és a virtuális gép) a CLASSPATH környezeti változó, vagy a –classpath kapcsoló alapján keresi meg

a csomagok helyét a file rendszerben.

A Java API előre definiált típusai is csomagokban találhatók.

A fordítási egység szerkezete

Egy fordítási egység az alábbi részekből áll:

csomagdeklaráció

importdeklarációk

típusdeklarációk (osztály vagy interface deklarációk)

Csomagdeklaráció

Csomagnév megadása (csomagdeklaráció):

package csomagnév

A csomagnév teljes hivatkozás kell legyen.

A fordítási egység elején szerepelhet, és csak egy ilyen deklaráció lehet. Minden fordítási egység csak egy csomaghoz tartozhat.

Ha elmarad, a fordítási egység egy névtelen csomaghoz fog tartozni (nem ajánlott).

Egy csomag szabadon bővíthető.

Import deklarációk

Egy másik csomagban deklarált publikus típust a teljes azonosítójával kell megnevezni. Ezt rövidíthetjük az

adott típus importálásával:

import A.B.C.T

Ezután a fordítási egységben elég a T típusnév megadása.

A fordító mindig a teljes azonosítót használja a munkája során.

Egy csomag valamennyi típusát is importálhatjuk az alábbi formában:

import A.B.C.*

Minden fordítási egységbe automatikusan importálódik a java.lang csomag összes típusa (import java.lang.*).

Szerepe nem azonos a C #include direktívájával, mert nem másolódik be hatására semmi, csak a hivatkozást

egyszerűsíti.

16. Osztályváltozó és osztálymetódus.

Osztályváltozó

A statikus adattag az osztály valamennyi objektuma számára egy példányban létezik, azok osztottan használják.

Miután az osztály egészére vonatkoznak, szokás osztályváltozóknak is hívni (globális változó az osztályra

nézve).

Nem a this pszeudó változó segítségével történik az elérése.

Az objektumok előtt kell létrejönnie.

Inicializálása az osztály inicializálás során történik.

(A JVM akkor inicializál egy osztályt, amikor először történik rá aktív hivatkozás (példányosítás, metódushívás,

változó hozzáférés).)

Az osztályon belül a nevével hivatkozhatunk. Hivatkozhatunk rá bármely objektum példánnyal.

Az osztály bármely metódusa használhatja.

Mivel egyetlen példány létrehozása nélkül is létezik, a hivatkozásban osztálynevet is használhatunk.

Osztálymetódus

Bár az eddigi metódusok csak egy példányban léteznek minden példány számára, de működésükhöz egy aktuális

példány szükséges (ezeket hívhattuk volna példánymetódusoknak is).

Metódus is kaphat static minősítést: osztálymetódus.

Az ilyen metódus a példányváltozókhoz és a this pszedó változóhoz nem férhet hozzá.

Következmény: csak osztályváltozókat és más osztálymetódusokat használhat.

Akkor is végrehajtható, ha az osztálynak nem léteznek példányai.

Hivatkozás:

- osztályon belül a nevével,

- minősített hivatkozásnál bármely példány vagy az osztály nevével. Egy program indulásakor nincs, ami példányt hozzon létre, ezért a main metódusnak static minősítésűnek kell

lennie.


17. A final minősítésű adattagok és metódusok.

A final minősítő

A final minősítő többféle célra is használható a Java nyelvben. Jelentése mindig "valami olyasmi, ami később nem változtatható meg".

Rokon a C nyelv const minősítőjével, de attól sokoldalúbb.

final adattagok

Deklaráció:

final típus azonosító=inicializáló kifejezés;

Az inicializáló kifejezés csak olyan elemeket tartalmazhat, amelyek az addigi deklarációk ismeretében

feldolgozhatóak.

Minden példányosítás során végrehajtódik, tehát a változó értéke objektumonként egyedi lehet.

Egyetlen metódus sem változtathatja meg az értékét.

static final adattagok

Deklaráció:

static final típus azonosító=inicializáló kifejezés;

Az inicializáló kifejezés csak konstansokat és olyan static adattagokat tartalmazhat, amelyek már deklaráltak.

Csak egyszer, az osztály inicializálása során hajtódik végre, tehát a változó értéke az osztály minden példánya

számára ugyanaz.

Egyetlen metódus sem változtathatja meg az értékét.

18. Az öröklődés fogalma, szintaktikai szabályai. Statikus és dinamikus típus fogalma.

Egy osztály deklarálható valamely más osztály (ősosztály vagy szülő osztály) leszármazottjaként.

A leszármazott osztály rendelkezik:

- a szülő osztály tagjaival, - a saját tagjaival.

Az ősosztály elemeinek az elérése a leszármazott osztályból nem feltétlenül garantált.

Az öröklődési hierarchia tetszőleges lehet. Egyetlen korlátozás: egy osztály még közvetett módon sem lehet saját

maga őse.

Az ősosztály továbbra is használható önmagában is.

Ha egy Java osztálynak nincs megadva őse, automatikusan az Object osztály leszármazottja lesz.

Minden osztálynak van tehát egy közös őse.

Szintaktika

[módosító] class név extends ősosztály {

// itt jön a saját tagok deklarációja

}

Statikus és dinamikus típus

Egy változó statikus típusa az, amelyet a deklarációjában megadtunk

- ez a változó teljes élete alatt változatlan.

Egy változó dinamikus típusa az általa éppen hivatkozott objektum tényleges típusa

- ez a program futása során bármikor változhat,

- a változó dinamikus típusa csak a statikus típus vagy annak leszármazottja lehet.

19. Konstruktorok az öröklődés során.

Konstruktorok öröklődés esetén

A konstruktor nem öröklődik (nem metódus).

Mind az ősosztály, mind a leszármazott osztály rendelkezhet konstruktorral (akár többel is).

Egy leszármazott objektum példányosításánál tisztázni kell:

- a konstruktorok végrehajtási sorrendjét,


- azt, hogy hogyan választhatjuk ki az ősosztály konstruktorai közül a végrehajtandót.

Konstruktorok végrehajtási sorrendje

Először mindig az ősosztály, majd a leszármazott osztály konstruktora hajtódik végre.

A pontos sorrend:

- az ősosztály adattagjainak inicializálása (az inicializátor kifejezések kiértékelésével),

- az ősosztály konstruktorának végrehajtódása,

- a gyermekosztály adattagjainak inicializálása,

- a gyermekosztály konstruktorának végrehajtódása.

20. Felüldefiniált metódusok: a definiálásra és a hívásra vonatkozó szabályok.

Használatának célja.

Metódus felüldefiniálás – alapszabályok

Egy ősosztálybeli metódus felüldefiniálásához a következő feltételeknek kell teljesülnie:

- a felüldefiniáló metódus visszatérési típusának, nevének, és paraméter szignatúrájának meg kell

egyeznie az ősosztálybeli metóduséval,

- a felüldefiniáló metódus hozzáférési kategóriája nem lehet szűkebb az eredeti metódusénál (bővebb

lehet),

- a felüldefiniáló metódus csak olyan ellenőrzött kivételeket válthat ki, amilyeneket az eredeti is

kiválthat.

Felüldefiniált metódushívása

A hívásban szereplő valamennyi információ illik minden metódus változatra (ez alapján nem lehet dönteni).

- a döntés alapja a hivatkozás dinamikus típusa,

- a döntés csak futás időben történhet,

- a felüldefiniáló metódus az ősosztály metódusát elérheti a

super.metódusnév(...) formájú hivatkozással.

Metódus felüldefiniálás – további szabályok

- Nem kötelező a leszármazás minden szintjén felüldefiniálni a metódust, egy osztály örökölheti a felüldefiniált metódust.

- Statikus metódus nem definiálható felül (értelmetlen lenne, mert hívása a statikus típus alapján

történik).

- Ugyanolyan nevű statikus metódus a leszármazott osztályban elfedi az ősosztály metódusát.

21. Absztrakt metódus és absztrakt osztály.

Absztrakt metódus és osztály

Gyakran előfordul a tervezés során, hogy egy osztály szintjén tudjuk, hogy valamilyen metódus szükséges lesz a leszármazottakban, de még nem lehet megadni az implementációját.

Ezért a Java nyelv megengedi törzs nélküli metódus definiálását.

Az ilyen metódust az abstract minősítővel kell ellátni.

Ha az osztály tartalmaz absztrakt metódust, az osztályt is az abstract minősítővel kell ellátni.

Formai szabályok:

- absztrakt egy metódus, ha nincs törzse; megvalósítást (törzset), majd csak a felüldefiniálás során kap,

- absztrakt metódusnak nem lehet módosítója a private, final, static hiszen az ilyen metódusokat nem

lehet felüldefiniálni,

- absztrakt egy osztály, ha van legalább egy absztrakt metódusa,

- absztrakt osztályt nem lehet példányosítani,

- egy absztrakt osztály arra szolgál, hogy ősosztálya legyen további osztályoknak, - a leszármazott osztály(ok) feladata az absztrakt metódusok felüldefiniálása,

- absztrakt osztály gyermeke lehet absztrakt, ha nem minden absztrakt metódust valósít meg,

- az absztrakt osztály is használható referencia statikus típusaként.

Az absztrakt metódusok szerepe:


- rögzít egy tervezési döntést (szükséges metódusok halmaza),

- kényszeríti a leszármazott osztály(ok) programozóját meghatározott metódusok definiálására.

Hibalehetőségek:

- törzs nélküli metódus, abstract minősítő nélkül,

- absztrakt metódust tartalmazó osztály abstract minősítő nélkül.

A fordítóprogram figyeli az ilyen hibákat.

22. A Java interface fogalma, a definíció szintaktikája. Interface implementálása.

Egy osztály interfészén a nyilvános elemeinek összességét értjük, ami a használatához szükséges.

Az információ rejtés elve miatt, általában csak metódusokból áll.

Specifikáció, tervezés során készül el.

Kényszeríti az osztály készítőjét a megfelelő elemek implementálására.

„Protokollok” (a kommunikáció szabályai) az objektumok között.

Interfészek a Java-ban

Mivel nincs globális változó, konstans, ezért lehetnek adat részei is.

Szintaktikája hasonló az osztályhoz, de a class kulcsszó helyett interface.

Kiterjeszthet más interfészeket (extends), létezik többszörös interfész-öröklés .

Az interfész nem tartalmaz végrehajtható kódot, azt a megvalósító osztályban (implements) kell megadni.

Megállapodás, hogy „I”-vel kezdődik a neve.

Szintaktika

[módosító] interface Iazonosito [extends Ios1[,Ios2]] {

[Elemek deklarációi]

}

Módosító lehet:

- public,

- abstract (elavult, mert minden interfész alapértelmezés szerint absztrakt).

Interfészek kiterjesztése

Minden interfész kiterjeszthet egy vagy több interfészt.

Fontos, hogy önmagát nem terjesztheti ki sem közvetve, sem közvetlen. Nem alakulhat ki körkörös lánc.

Interfészek láthatósága

- public: nyilvános; ebben az esetben az interfészt azonos nevű fájlba kell írni, 1 interfész 1 fájl,

- - : csomagszintű; ilyenkor csak abban a csomagban lehet használni, de több is lehet egy forrásfájlban.

Szabályok

Ha egy osztály implementál egy interfészt, akkor köteles annak minden metódusát implementálni!

Az implementált elemeket nem módosíthatja.

Metódusok esetében a fejlécnek teljesen egyeznie kell!

Azonos nevű elemet az öröklődés során és az implementálás során nem kaphat meg (fordítási hiba).

(Azaz például az ősosztályban és valamelyik implementált interface-ben nem lehet azonos nevű metódus.)

Interfész használata

Egy interfész új referencia típust vezet be, ezért mindenhol használható, ahol egy osztály.

Változó deklarációban szerepelhet (megadhatja annak statikus típusát).

Bármelyik osztállyal helyettesíthető, amely implementálja (megadva ezzel a dinamikus típust).

23. A kivétel fogalma és kivételkezelés utasításai a Java nyelvben. Kivétel keletkezése.

Kivétel – exception

Futás idejű hiba/nem normális eset.

Általában valamilyen hibához kötődik.

Számos beépített kivétel.


Saját kivétel definiálható.

A Java szemléletében a kivétel egy objektum, ami a kivétel bekövetkezésekor jön létre.

Saját (programozói) kivétel kiváltása:

throw objektum;

Kivétel – hiba

A kivétel keletkezésekor szokásos teendők:

- értesíteni a felhasználót, vagy naplózni,

- majd valamilyen plusz műveletek után

- folytatni az alkalmazást,

- esetleg kilépni, súlyos hiba esetén,

- ellenőrzött kilépés lehetséges (például előtte minden értékes adat elmenthető).

A kivétel objektum tartalmazhat információkat a kivétel keletkezéséről, amelyet felhasználhatunk.

Kivételkezelés utasításai

try védett kód (blokk) kijelölése

throw kivétel dobása, generálása catch kivétel elkapása, a blokkban definiált utasítások végrehajtása

finally végül, akár volt kivétel, akár nem volt, lefut

try blokk

A védett kódot try blokkban helyezzük el:

try { utasítások }

A blokkban keletkezett kivételt mi kezelhetjük le.

A blokkok egymásba ágyazhatóak.

Érdemes minél kisebb blokkokat definiálni.

Kivétel keletkezik, ha a try blokkban egy throw utasításra fut a vezérlés.

Formája:

throw new kivételTípus(konstruktor paraméterek)

A throw paramétere nem maradhat el!

Kivétel keletkezése

Kivétel keletkezhet az alábbi módokon:

- implicit módon: a JAVA rendszerből indul ki, azaz valamely utasítás vagy API elem végrehajtása során

keletkezik,

- a programozó kódjában keletkezik, közvetlenül egy throw utasítás végrehajtásával,

- aszinkron kivétel, amely a program egy másik szálán lépett fel.


A kivétel keletkezése esetén:

- az első kivételt kiváltó utasítással befejeződik a try blokk végrehajtása,

- kilép a blokkból a vezérlés, rendcsinálással

- verem visszaállítása,

- lokális objektumok megszüntetése,

- védett változók lezárásának megszüntetése,

- létrejön a throw utasításban megjelölt objektum egy példánya.

24. Kivétel elkapása és lekezelése. A finally blokk szerepe.

A kivétel elkapása

A kivétel objektumot minden esetben a virtuális gép hozza létre.

A kivétel lekezelését szolgáló utasítások catch blok(kok)ban helyezkednek el.

Formája:

catch (típus paraméter) {

utasítások

} A catch minden esetben a try blokkot követi, nem lehet köztük más utasítás.

Egy try blokkhoz tartozhat több catch is.

A virtuális gép megkeresi a sorrendben első "illeszkedő" blokkot, és annak végrehajtásával folytatódik a program.

Az illeszkedés feltétele: a kivétel objektum típusa megegyezik a catch blokk fejében megadott típussal, vagy

annak leszármazottja.

A kiválasztott blokk végrehajtása során a paramétere úgy használható, mint a függvények esetén a formális

paraméter.

(Így lehet felhasználni a kivétel objektumban tárolt információkat.)

A futás az utolsó catch utáni sorral folytatódik.

Minden ellenőrzött kivételt kezelni kell (fordítási hiba, ha van lekezeletlen kivétel)!

Ha a catch blokk végrehajtása során újabb kivétel keletkezik, az eredeti kivétel kezelése megszakad, és az új

kivétel lekezelése kezdődik el.

Ha egyetlen catch blokk sem illeszkedett a kivételre, a keresés a beágyazó try blokk catch blokkjaival folytatódik, amíg sikeres nem lesz.

Ha a keresés belülről kifelé minden try blokkot megvizsgált, és nem talált egyezést, a program terminálódik, és

kiíródik a kivétel stack (lekezeletlen kivétel).

Megjegyzés: a try blokk kivételt kiváltó utasítása utáni utasítások tehát mindig kimaradnak!

A finally blokk

Nem kötelező.

A cacth(ek) után szerepelhet. Az utolsó catch blokk és a finally blokk között nem lehet más utasítás.

Nem lehet paramétere.

Minden esetben lefut:

- ha kivétel keletkezett a try blokkban, egy catch blokk végrehajtása után,

- ha nem volt kivétel, a try blokk utolsó utasítása után.

Alkalmas például fájlok, adatbázis kapcsolatok lezárására.

25. Előre definiált és saját kivétel osztályok.

Kivétel osztályok


Az Error és a RuntimeException osztályú kivételek nem ellenőrzött kivételek, az összes többi ellenőrzött

kivétel. Ajánlott: minden programozó által definiált kivétel az Exception osztályból származzon (valamennyi ilyen

kivétel ellenőrzött kivétel, kötelező lekezelni).

Konvenció: minden kivételosztály neve ValamiException legyen, ahol a Valami a kivétel jellegére utal.

Az Exception osztály

Van egy String paraméterű konstruktora, amellyel egy leírás definiálható a kivételhez.

Számos hasznos metódust definiál, amely örökölődik, és szükség esetén felüldefiniálható.

- String toString(): visszaad egy sztringet, amely az osztály azonosítójából és a konstruktorban megadott

sztringből áll

- String getMessage(): visszaadja a konstruktorban megadott sztringet

- printStack(): kiírja a keletkezett kivételeket, a keletkezésük sorrendjében és megadja a keletkezésük

helyét

- hasznos lehet a hibakereséshez,

- paraméter nélkül a standard hibacsatornára ír, de paraméterben megadható, hogy hová írjon.

Saját kivétel osztály

Ajánlások: - az Exception leszármazottja legyen,

- név konvenció! (ValamiException),

- a konstruktorának a paraméterei között legyen egy String, amivel az ősosztály konstruktorát hívja meg,

- a további paraméterek a hibára jellemző adatokat fogadhatnak,

- a metódusai a catch blokkban használhatók a kivétel lekezelése során,

a kivételek csoportosítására célszerű leszármazási hierarchiát létrehozni a saját kivételosztályok között is.

26. Az ellenőrzött és a nem ellenőrzött kivétel fogalma. Kivételek specifikálása.

Nem ellenőrzött kivételek

Az Error és a RuntimeException osztályból származó kivételek.

- Error: rendszerszintű hiba a JVM működésében. (Pl. OutOfMemoryError),

- RuntimeException: a program számos pontján keletkezhetnek, ezért nem célszerű kötelezővé tenni a

lekezelésüket. (Pl. ArrayIndexOutOfBounds).

A programozó, ha akarja, lekezelheti.

Lekezeletlen kivétel esetén a program terminálódik, és kiíródik a kivétel stack.

Ellenőrzött kivételek

A fordítóprogram hibát jelez, ha nincs lekezelve!

A kivétel lekezelésének módjai:

- a try blokk utáni valamelyik catch blokk elkapja, és teljes mértékben lekezeli; a metódus futása

folytatódik a catch blokkok utáni első utasítással,

- a try blokk utáni valamelyik catch blokk elkapja, és részben lekezeli:

- a lekezelés egy olyan throw utasítással fejeződik be, amely a paraméterül kapott kivétel objektumot tartalmazza;

a metódus futása befejeződik,

- a metódus fejlécében ezt a kivételt specifikálni kell,

- a metódus nem kezeli le a kivételt, de specifikálja azt a fejlécében; a metódus futása befejeződik,

- ez akkor szükséges, amikor az adott metódus nem, csak a hívó tudja értelmesen lekezelni a kivételt,


- a hívó is tovább adhatja a kivétel lekezelését, így a kivétel tetszőleges hívási mélységből is eljuthat

oda, ahol

lekezelhető.

Kivételek specifikálása

Ha egy metóduson belül kivétel keletkezhet, de nem tartalmaz catch utasításokat annak kezelésére.

Ilyenkor a metódushívójának kell azokat lekezelni.

Erre számítania kell, ezért az ilyen kivételeket a metódus fejlécében specifikálni kell.

Formája:

metódusnév([parameterlista]) [throws kivételosztály1 [, kivételosztály2, …] ]

27. Beágyazott osztályok.

Osztálydefiníció a programon belül

Eddig egymás mellé rendelt osztály és interface definíciókat láttunk, de a Java nyelvben ezek a definíciók

beágyazhatók:

- osztály hatáskörbe (tagosztályok),

- utasításblokkba (lokális osztályok),

- egy utasításba (névtelen osztályok).

Tagosztály

Osztálydefiníció egy osztály (befoglaló osztály) hatáskörében.

A befoglaló és a tagosztály kölcsönösen hozzáférnek egymás tagjaihoz (a private tagokhoz is).

A nevek minősítése nem szükséges.

A tagosztályok is öröklődnek.

A befoglaló osztályon kívüli hozzáférés a tagosztály hozzáférési kategóriájának megfelelően lehetséges. A tagosztály tagjaira való hivatkozáshoz a nevet minősíteni kell.

Statikus tagosztály

Static módosítóval.

Emellett még public, protected, private módosítója is lehet.

A program csomagon belüli tagolásához: egy típus, amely a befoglaló osztály hatáskörében van.

Használható a befoglaló osztályon belül típusként.

Ha nem private, a programban ugyanúgy használható, mint bármely más osztály (kivéve a bonyolultabb

hivatkozást).

Alkalmazási területei:

- egy segédosztályt el akarunk rejteni a külvilág elől (private tagosztály),

- egy osztály megvalósításakor egy olyan segédosztályra van szükség, amelyeknek hozzá kell férnie az

osztály privát tagjaihoz,

- ki akarjuk fejezni, hogy egy osztály vagy interface egy másiknak logikai alárendeltje.

Nem statikus tagosztály

A befoglaló és a tagosztály példányainak kapcsolatát implementálhatjuk vele.

A tagosztály egy adott példányához a befoglaló osztály pontosan egy példánya tartozik. Ellenkező irányban: a befoglaló osztály egy példányához a tagosztály tetszőleges számú (0, 1, 2, …) példánya

tartozhat.

A fenti kapcsolat automatikuson rögzítődik, és fennáll mindaddig, amíg a befoglaló osztály példánya "él".

(Ha például egy "külső" osztály metódusa példányosít egy beágyazott típusú objektumot, az a befoglaló

objektumhoz kapcsolódik, és túléli a metódust (nem úgy, mint egy egyszerű osztály lokális példánya).)

28. Az osztály interface fogalma és a jól tervezett osztály interface jellemzői.

Osztály interface fogalma

public metódusok összessége:

- ezeket kell ismernie az osztály használójának,

- használatukhoz nem szükséges ismerni az osztály implementációs részleteit.


protected metódusok és adattagok:

- kibővíti az interface-t a leszármazott osztályok számára,

- használata veszélyeket rejt magában, mert implementációs függést hoz létre az ős és a leszármazott

osztály között

Technikai szempontból az interface részét képezik az esetleges public minősítésű adattagok is, de használatuk

nem ajánlott (tilos, ugyanis ellentmond az információrejtésnek).

A jó osztály interface

Teljes

- minden funkciót tartalmaz, ami az osztálytól elvárható,

- nem az adott alkalmazás szempontjai határozzák meg,

- újrafelhasználható egységet alkot az osztály.

Minimális

- nem tartalmaz a felhasználó számára érdektelen (esetleg veszélyes) elemeket, - belső felhasználású funkciók private vagy protected minősítésűek,

- a belső áttervezés nincs rá hatással.

Kezelhető méretű

- általában legfeljebb néhány tíz metódus,

- a sok funkció között nagyobb valószínűséggel lesznek hasonlóak (félreértés veszélye),

- a terjedelmes interface általában tervezési hibára utal:

- az interface része belső funkció is,

- az osztály határait nem jól állapítottuk meg, és túl sok feladatot akarunk rábízni

(a helyes architektúra kialakítása érdekében az eredetileg tervezett osztályt több osztályra kell

bontani,

és ezek között leszármaztatással vagy más mechanizmussal megteremteni a kapcsolatot).

Az osztály interface részei

Kezelő tagok és metódusok: konstruktorok, örökölt metódusok (pl. toSting, clone, …), sokszor nem is a

programozó, hanem a program implicite hívja meg.

Elérési függvények: az adattagok értékének elérésére vagy azok értékének módosítására.

Munkavégző függvények: az osztály lényegi funkcióit aktivizáló függvények.

29. Az általánosítás/pontosítás (is-a) és a tartalmazás (has-a) kapcsolat

implementálási lehetőségei Java nyelvi eszközökkel.

Az általánosítás/pontosítás implementálása

Leszármaztatási mechanizmus (öröklődés) segítségével.

A leszármazott osztály objektuma egyben ős objektum is.

A tartalmazás implementálása

Kétféle tartalmazás kapcsolat:

- aggregáció: a rész az egészhez tartozik, de önállóan is létező entitás,

- kompozíció: a rész önmagában nem létezhet, csak valaminek a részeként.

A tartalmazás implementálása: aggregáció

A tag objektum referenciája a tartalmazó osztályban.

Ez adattag, tehát általában private!

Az egy-több kapcsolat (több "rész") megvalósítása különböző adatszerkezetekkel lehetséges (tömb, Vektor stb). A referenciák beállítása általában a befoglaló osztály konstruktorának feladata, már létező ("külső") objektumok

referenciáinak felhasználásával.

Használat kapcsolati implementálása

Fajtái: (CX és CY osztályok)

- CX használja a CY nevet (feltételezi, hogy CY hozzáférhető a használat helyén):

- adattag típusa,

- metódus visszatérési értékének vagy paramétereinek típusa,

- CX használja a CY osztályt (a hozzáférési kategóriák alapján):

- meghívja a CY egy metódusát,

- írja/olvassa a CY egy adattagját,


- CX létrehoz egy CY típusú objektumot.

Probléma a használat kapcsolat implementálásával: csak közvetett nyelvi eszközök jelzik az ilyen

kapcsolatokat

Korlátozó tényezők:

- csomagok és az osztályok hozzáférési kategóriája,

- osztály tagjainak hozzáférési kategóriája.

OOP 2010 Tételek kidolgozva by NagyImre

Documents

Transcript of OOP 2010 Tételek kidolgozva by NagyImre