Java Programozás 3. Ea: Java osztályok. OOP alapalapok

Java Programozás 3. Ea: Java osztályok OOP alapalapok 62/1 B ITv: MAN 2018.02.05

Osztály fogalma 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ály egy új objektumot, vagy új típust tartalmaz 62/2

Osztály fogalma Az osztály fejlécből és törzsből áll módosítók class osztálynév { tagok definíciói 62/3 Fejléc: módosítók class osztálynév A módosítók feladata az osztályok láthatóságának (elérhetőségének) szabályozása Pl: public (a többi rövidesen) public: az osztály látható, használható bármelyik másik osztályban class: osztályt definiáló kulcsszó osztálynév: tetszőleges egyedi azonosító. (lásd: szokások!) Törzs: { között, tagok definícióit tartalmazza

Osztály fogalma Az osztály tagjai lehetnek: adattag (mező) konstruktor inicializáló blokk metódus tag tag osztály (interfész) A tagok definiálásának sorrendje tetszőleges. Ajánlások, szokások (konvenciók) vannak! 62/4

Osztály fogalma A Kör osztály definíciója: public class Kör { double kp_x; double kp_y; double sugár; 62/5 void eltol(double dx, double dy) { kp_x += dx; kp_y += dy; void átméretez(double ujsugár) { sugár = ujsugár; Egységbezárás: Az osztály az adatait és a metódusait egy egységként kezeli, és elzárja őket a külvilágtól. Tulajdonságok: adattagok Viselkedési jellemzők: metódusok Adattagok Metódusok Objektum

Osztály fogalma Adattagok Metódusok Az egységbe zárás alapelvének implementálása: minden osztály saját hatáskörrel rendelkezik. Egy osztály minden eleme tehát lokális az osztályra nézve. Következmények: Különböző osztályokban használhatjuk ugyanazt az azonosítót eltérő értelemben! Az osztályon belül az elemek egymásra a nevükkel hivatkozhatnak. A metódusok használhatják az adattagokat és a többi metódust. 62/6

Osztály fogalma Adattagok Metódusok Egy Java program objektumai üzenetküldéssel kommunikálnak egymással, amely során az egyik egy konkrét feladat elvégzésére kéri a másikat. Ez a megszólított objektum egy - a kezdeményező által látható, elérhető - metódusának meghívását jelenti. Egy objektum azon metódusainak összességét, amelyeken keresztül meghívható, az objektum interfészének nevezzük. Az objektumoknál szabályozható, hogy mely adattagjai legyenek láthatók, ill. mely metódusai és konstruktorai legyenek meghívhatók más objektumok által, valamint melyek legyenek csak az adott objektum által hozzáférhetők. Ezt az eszközrendszert nevezzük egységbezárásnak. 62/7

Példányosítás A Kör egy típus Deklarálhatunk ilyen típusú változókat: Létrehozhatunk példányokat belőle, pl: A példányosítás kifejezés eredménye egy megfelelő típusú (példánkban: Kör) referencia, amely a létrejött objektumra mutat. Ezt a referenciát eltárolhatjuk referencia változókba: Kör a,b; a = new Kör(); b = new Kör(); Kör a, b; new Kör(); 62/8

Referencia változó típus név érték Az osztályok referencia típusú változók, ez azt jelenti, hogy értékadásnál nem maga az érték, hanem annak hivatkozása (memóriacíme) rendelődik a változóhoz. Az referencia értéke (a cím) a programozó számára hozzáférhetetlen (és szükségtelen is). Létezik null értékű referencia, ami még (vagy már) nem mutat sehova Ha deklarálunk (definiálunk) egy referencia típusú változót, a memóriában lefoglalódik számára hely, de nem jön létre objektum (pl. Kör k;) Kör a Objektum létrehozásához a new operátort kell használni! Kör a = new Kör(); Kör a 0 0 0 62/9

Referencia változó Mit tehetünk a referenciákkal? Definiálhatjuk: Kör a, b; Értéket adhatunk neki (= operátorral) típus név érték Kör a Kör b a = new Kör(); Referencia átadás: b = a; b ezután ugyanarra az objektumra mutat, mint a Két referencia közötti egyenlőséget vizsgálhatjuk (==,!=) boolean egyenlo = (a == b); Konvertálhatjuk (később) Hivatkozhatunk a tagjaira a.kp_x = 2; a.eltol(3, 2); Kör a 0 0 0 Kör b 62/10

Referencia változó típus név érték Definiált, de nem inicializált referenciával nem lehet semmilyen műveletet végezni, a fordító hibát jelez! public class AutoP { public static void main(string[ ] args) { Auto a; System.out.println(a); 62/11

Referencia változó típus név érték public class AutoP { public static void main(string[ ] args) { Auto a = new Auto("PXM218"); Auto b = new Auto("PXM218"); System.out.println(a==b); Két referencia akkor sem egyforma, ha minden adattagjuk megegyezik! 62/12

Osztály fogalma Végrehajtható kódot tartalmazó osztály készítése: public class KörProgram { public static void main(string[ ] p){ Kör a, b; a = new Kör(); a.kp_x = 0; a.kp_y = 0; a.sugar = 10; b = new Kör(); b.kp_x = 5; b.kp_y = 8; b.sugar = 3; b.eltol(5, 5); 62/13 Végrehajtható metódus Deklarálás Hivatkozás adattagra Inicializálás Hivatkozás: az objektum nevével minősítve, a. (pont) operátorral Hivatkozás metódusra Hivatkozás: névvel, zárójelben paraméterekkel. A hivatkozás a metódus elindítását jelenti.

Teszt 1. A Teszt.java forrásállományban a main metódus mely blokkban szerepelhet? public class teszt {.. public class Teszt {.. private class Teszt {.. public Class Teszt {.. 62/14

Teszt 2. Melyik objektum szerepel biztosan egy programosztályban? Adattag Konstruktor Metódus Változó Egyik fenti objektum sem 62/15

Tagok hozzáférési kategóriái Az információ rejtés alapelv megvalósításának eszköze. Feladatuk az objektumok (osztály, metódus, adattag) láthatóságának (elérhetőségének) szabályozása 62/16 Módosító private nincs protected public Hozzáférési kategória Privát: más osztályból nem látható, de az adott osztály összes példánya számára elérhető Alap (félnyilvános): csak az azonos csomagban levő osztályok érhetik el (angolul default vagy packageprivate) Védett: az adott csomagban lévő és a leszármazott osztályok érik el Nyilvános: bármely csomagban levő bármely osztályból elérhető

Védettség Tagok hozzáférési kategóriái Az egyes hozzáférési szintek láthatósága: Osztály Csomag Leszármazott Összes private X NO NO NO nincs X X NO NO protected X X X NO public X X X X Az osztályon belül bármilyen hozzáférésű objektum elérhető Azonos csomagban a private objektumok már nem látszanak A leszármazott osztályból csak a védett és a nyilvános objektumok érhetők el Az összes (idegen) osztályból csak a public objektumok érhetők el 62/17

Tagok hozzáférési kategóriái Az alkalmazása a programozóra van bízva! Alkalmazás: "Egy objektum adatai a külvilág (más objektumok) számára hozzáférhetetlenek." Ebből következik: minden adattag private módosítót kell kapjon!!! "Egy objektum a külvilággal csak az interfészén keresztül tarthatja a kapcsolatot." Ebből következik: Csak azok a metódusok legyenek publikusak, amelyek a külvilággal tartják a kapcsolatot!!! 62/18

Tagok hozzáférési kategóriái Osztály csak nyilvános vagy félnyilvános lehet. Adattag és metódus bármelyik kategóriába tartozhat Az információrejtés alapelvének betartása érdekében minden elem a lehető legszűkebb kategóriát kapja. Szokásos konvenciók: 62/19 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.

Teszt 3. Egy osztálynak milyen szintű adattagjai lehetnek? csomagszintű példányszintű osztályszintű blokkszintű 62/20

Tagok hozzáférési kategóriái A Kör osztály definíciója, az adatrejtés elvét betartva: public class Kör { private double kp_x; private double kp_y; private double sugár; public void eltol(double dx, double dy) { kp_x += dx; kp_y += dy; public void átméretez(double ujsugár) { sugár = ujsugár; 62/21

Tagok hozzáférési kategóriái A KörProgram hibás lett! Miért? public class KörProgram { public static void main(string[ ] p){ Kör a, b; a = new Kör(); a.kp_x = 0; a.kp_y = 0; a.sugar = 10; b = new Kör(); b.kp_x = 5; b.kp_y = 8; b.sugar = 3; b.eltol(5, 5); 62/22 Adattagok privátak, elérésük nem lehetséges! Megoldás: az adattagokat elérő setter metódusok a Kör osztályban! public void setkp_x(double p_kp_x) { kp_x = p_kp_x; public void setkp_y(double p_kp_y) { kp_y = p_kp_y; public void setsugar(double p_sug) { sugár = p_sug;

Tagok hozzáférési kategóriái A javított KörProgram. public class KörProgram { public static void main(string[ ] p){ Kör a, b; a = new Kör(); a.setkp_x(0); a.setkp_y(0); a.setsugar(10); double r = a.getsugár(); double terület = r*r*math.pi; System.out.println(terület); A setter metódusokhoz hasonlóan getter metódusokat is használunk az adattagok értékének eléréséhez. public double getkp_x() { return kp_x; public double getkp_y() { return kp_y; public double getsugár() { return sugár; 62/23

Objektumok inicializálása Adattagok Metódusok Az adattagok egy objektum létrehozásakor automatikusan inicializálódnak nullszerű értékkel: numerikus típusúak 0-val, char típusú 0 kódú karakterrel, boolean típusú false értékkel, referencia null értékkel. Az esetek 99%-ban más értékre lenne szükség, ezért saját magunknak kell beállítani az értékeket. Megoldható ez egy metódussal, amit a programozó meghív a példányosítás után. 62/24

Objektumok inicializálása A Kör osztály adattagjait beállító metódus 62/25 public class Kör { private double kp_x; private double kp_y; private double sugár; public void setkör(double dx, double dy, double s) { kp_x = dx; kp_y = dy; sugár = s; Ha elfelejtjük meghívni a metódust, a program hibásan fog működni! Hibalehetőség! Megoldás: konstruktor használata

Konstruktor A konstruktor: speciális metódus, amelyet nem lehet meghívni normál módon, hanem automatikusan hívódik meg az osztály példányosításakor. Szerepe az objektum induló állapotának beállítása (pl. adattagok inicializálása). A konstruktor szintaktikája: módosítók azonosító (paraméterlista) { utasítások 62/26 Metódushoz hasonló szintaktika, de Az azonosító kötelezően az osztály neve kell legyen Nincs visszatérési érték típus megadás Lehetnek paraméterei, amelyeknek a példányosításkor adhatunk meg értékeket. Csak a new operátorral hívható

Konstruktor A Kör osztály konstruktora 62/27 public class Kör { private double kp_x; private double kp_y; private double sugár; public Kör(double dx, double dy, double s) { kp_x = dx; kp_y = dy; sugár = s; A konstruktor: Túlterhelhető, több is lehet belőle (eltérő paraméterekkel) A konstruktor az osztály bármely metódusát használhatja

Konstruktor A konstruktor törzse a példában pontosan ugyanaz, mint a setkör metódusé. Különbségek: A konstruktorhoz nem szükséges előzőleg már létrehozott objektum. A konstruktor a példányosítás során pontosan egyszer és automatikusan hajtódik végre. A konstruktor az objektum élete során többet nem hajtható végre. A setkör függvény feltételezi, hogy az aktuális objektum már létrejött. Explicite meg kell hívni, és ez az objektum élete során akárhányszor megtörténhet. 62/28

Konstruktor Egy osztálynak mindig van legalább egy konstruktora Ha a programozó nem ír egyet, akkor a fordító hozzárendeli az osztályhoz az implicit konstruktort Az implicit konstruktor public, paraméter nélküli, törzse üres. Ha egy osztálynak nincs explicit (programozó által írt) konstruktora, akkor csak paraméter nélküli példányosítás lehetséges. Ha egy osztálynak van legalább egy explicit konstruktora, akkor paraméter nélküli példányosítás csak akkor lehetséges, ha a programozó definiált paraméter nélküli konstruktort. Az implicit konstruktor ilyenkor ugyanis nem rendelődik hozzá az osztályhoz. 62/29

Konstruktor A javított KörProgram. Példányosítás konstruktorral. public class KörProgram { public static void main(string[ ] p){ Kör a, b; a = new Kör(0, 0, 10); b = new Kör(5, 8, 3); Kör a Kör b Kör a 0 0 10 Kör b 5 8 3 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ó. 62/30

Példányosítás A legegyszerűbb mód egy osztály típusú változó definiálása. Formája: 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). Lefut a konstruktor A lefoglalt memóriaterületre való hivatkozás kerül a változóba. 62/31

Teszt 4. Jelölje meg az igaz állításokat! Van olyan metódus, melynek egyáltalán nincs visszatérő értéke (void sem!) Az implicit konstruktornak nincs bemenő paramétere, de törzsében lehetnek utasítások Egy osztálynak minden esetben van paraméter nélküli konstruktora A konstruktor lehet private hozzáférésű 62/32

Teszt 5. Helyes vagy hibás az alábbi kód? 62/33 public class Pont { int x; int y; Pont (int a, int b){ beallit(a, b); void beallit(int a, int b){ x = a; y = b;

Teszt 6. Helyes vagy hibás az alábbi kód? 62/34 public class Pont { int x; int y; Pont (int a, int b){ beallit(a, b); boolean beallit(int a, int b){ x = a; y = b; return false;

Teszt 7. Helyes vagy hibás az alábbi kód? 62/35 public class Pont { int x; int y; Pont (int a, int b){ x = a; y = b; Pont (int a){ this(a, 0);

Teszt 8. Helyes vagy hibás az alábbi kód? 62/36 public class Pont { int x; int y; Pont (int a, int b){ beallit(a, b); private void beallit(int a, int b){ x = a; y = b;

Példányosítás inicializáló blokk import java.util.date; public class Dolgozo { private String nev; private Date belepes; { 62/37 belepes = new Date(); public Dolgozo (String nev){ this.nev = nev; public String tostring(){ return "Név: "+nev+", belépett: "+belepes; public class DolgozoProgram { public static void main(string[ ] args) { Dolgozo d = new Dolgozo("Jenő"); System.out.println(d); Osztálydefiníción belül elhelyezett kódblokk, amely példányosításkor a konstruktor hívása előtt hajtódik végre.

Példány élettartam Létrejön példányosításkor. Megszűnik:? Automatikus szemétgyűjtő (garbage collector): Minden objektumról nyilvántartja, hogy hány referencia hivatkozik rá, amelyik objektumra egy sem azt megszünteti. (Pontosan mikor?) Egy referencia objektumra hivatkozása megszűnik, ha megszűnik maga a változó, megváltozik a változó értéke, a változónak a null értéket adjuk 62/38

Osztálydefiníció Adattag Adattag: az osztály példányainak egyedi jellemzőit, tulajdonságait tároló adat (nevezik tagváltozónak is) 62/39 Deklarálása: hozzáférés típus azonosító; Hozzáférés: nyilvános, félnyilvános, privát, védett Az információrejtés alapelvének betartása miatt mindig a lehető legszűkebb hozzáférést kell megadni! Sosem lehet adattag public hozzáférésű! Ha nem inicializáljuk az adattagot a definícióban, akkor automatikusan inicializálódik, nullszerű értékkel, ezt nem érdemes kihasználni. A definícióban, inicializáló blokkban, konstruktorban minden adattagot inicializáljunk. Szokás minden adattagot külön sorban definiálni

Osztálydefiníció Metódus Metódus: az osztály adattagjainak viselkedését leíró kód Egy osztályhoz több metódus tartozhat azonos névvel, de eltérő paraméterszignatúrával (túlterhelés) Paraméterszignatúra: a formális paraméterek száma és típus-sorrendje (a visszatérő érték típusa nem számít!) Deklarálás: hozzáférés visszatérő_típus név (paraméterek) { utasítások 62/40 Ha nincs visszatérő típus, akkor void Hozzáférés: nyilvános, félnyilvános, privát, védett static: osztályszintű abstract: nincs a metódusnak törzse final: öröklődéskor nem írható felül a metódus

Teszt 9. Jelölje meg az összes igaz állítást! Minden metódusnak van visszatérési értéke Egy függvényt meg lehet hívni eljárásként is A metódus fejében legalább egy módosítót mindenképpen meg kell adni Minden metódus blokkjában kötelezően szerepelnie kell a return utasításnak 62/41

Metódusnév túlterhelés (overloading) Egy osztályhoz több metódus is tartozhat azonos névvel, de különböző paraméterszignatúrával (a formális paraméterek száma és típus-sorrendje). A visszatérési érték típusa ebből a szempontból közömbös. A metódus hívásakor a fordítóprogram az aktuális paraméterek szignatúrája alapján dönti el, hogy melyik metódust kell alkalmaznia. Ha egy megfelelőt sem talál, vagy ha többet is talál hibajelzést ad. Egy osztályhoz úgy tartozhat több azonos nevű metódus, hogy: 62/42 az osztályban definiálhatók azonos nevű metódusok ugyanilyen nevű metódusokat örökölhet is az osztály A saját és örökölt metódusok együttesére érvényes a túlterhelés szabályrendszere

Teszt 10. Helyes vagy hibás az alábbi kód? public class PrbClass { double x; public int szamol(int a){ return (int)(x/a); public double szamol(int a){ return x/a*100; 62/43

Osztályszintű tagok Az adattagokból minden objektumnak saját készlete van. Ezeket ezért szokás példányváltozónak is nevezni. Ha az adattag deklarációja elé kitesszük a static minősítőt, osztályszintű adattagot, osztályváltozót kapunk A statikus adattagból csak egyetlen darab jön létre, minden példány eléri, közösen, osztottan használják Inicializálása az osztály első inicializálásakor történik Hivatkozhatunk rá az osztály bármely példányával Hivatkozhatunk rá az osztály nevével is 62/44

Osztályváltozó és osztálymetódus. Példakód class Teszt { int i; static int k; 62/45 Teszt(int i){ this.i = i; static void setk(int z){ k = z; public class Program{ public static void main(string args[ ]) { Teszt t = new Teszt(3, 5); Teszt.setK(7); System.out.println(t.k); static void setk(int k){ this.k = k; java Fut 7 Ha a setk metódus nem lenne static, a Program osztályból nem használhatnánk! A this használata helyes vagy hibás? Hibás! Cannot make a static reference to the non-static method setk(int) from the type Teszt

Osztályszintű tagok osztálymetódusok Létrehozásuk oka: akkor is használhatók, ha az osztálynak nem léteznek példányai. Létrehozásuk: a metódust static minősítővel látjuk el Hivatkozás: osztályon belül névvel, osztályon kívül minősített hivatkozással: az osztály vagy bármely példányának neve, pont, metódusnév Előző oldali példában: Teszt.setK(7); Osztálymetódusban a this és a super referenciák nem használhatók! A programosztályokban a main metódus mindig statikus! 62/46

Osztályszintű inicializáló blokk public class Dolgozo { private String nev; private static int jutalom; static { jutalom = 50000; public Dolgozo (String nev){ this.nev = nev; public String tostring(){ return "Név: "+nev+", jutalom: "+jutalom; public class DolgozoProgram { public static void main(string[ ] args) { Dolgozo d = new Dolgozo("Jenő"); System.out.println(d); 62/47

Osztályszintű inicializáló blokk Javaban csak példányszintű konstruktor létezik, osztályszintű nincs, ezt pótolja az osztályszintű inicializáló blokk Jellemzői: Több is lehet belőle egy osztályban Az osztály betöltődésekor (az osztályra történő első hivatkozáskor) fut le Szerepe: a statikus tagok inicializálása, bonyolultabb esetben. Pl. egy tömb elemeinek inicializálása A "statikus kontextus" része, ezért nem lehet benne példányszintű tagokra hivatkozni 62/48

Belső osztályok Az eddigi példákban egymás mellé rendelt osztály definíciókat láttunk. (top level class) A Java nyelvben ezen kívül az osztály definíciók beágyazhatók osztály hatáskörbe (tagosztályok) (nested class) utasításblokkba (lokális osztályok) (local classes) egy utasításba (névtelen osztályok) (anonymous classes) 62/49

Tagosztály Előnye: 62/50 Hozzáférnek a beágyazó osztály private tagjaihoz is. Korlátozhatjuk a tagosztály hatáskörét (lehet akár private is). Könnyebben karbantartható lesz. Egy helyen vannak a szorosan kapcsolódó osztályok. Hátránya: Bonyolultabb (hosszabb, nehezebben olvasható) lesz a beágyazó osztály definíciója. A tagosztály önállóan nehezen (vagy egyáltalán nem) használható (de nem is ez a szerepe). Elérés kívülről: Ha nem private, akkor más osztályból is elérhető: Beágyazó.Tag néven.

Tagosztály Példányszintű tagosztály Definíció: ua. mint egy normál osztály esetén Korlátozás: Nem lehetnek statikus tagjai (kivétel statikus konstans) public class Kulso { private class Belso { A Belso osztály (csakúgy, mint más példányszintű tagok) a Kulso egy példányához kötődik. 62/51

Tagosztály Példányszintű tagosztály Tagosztály példányosítása: példányváltozó.new Belso() Kulso a = new Kulso(); Kulso.Belso b = a.new Belso(); Természetesen ha az aktuális példányhoz akarunk létrehozni példányt, akkor lehet new Belso() is. Tagosztályon belül a beágyazónak is van aktuális példánya és a tagosztálynak is, a kettőt a this minősítővel tudjuk megkülönböztetni. Osztályszintű tagosztály: A tagosztály előtt szerepel a static módosító 62/52

Tagosztály 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. 62/53

Tagosztály Példakód class Outer { private int num = 25; 62/54 private class InnerClass { public void print() { System.out.println("Num="+num); void displayinner() { InnerClass inner = new InnerClass(); inner.print(); A displayinner metódus eléri az InnerClass osztályt, ami hozzáfér a private num adattaghoz. public class OuterP { public static void main(string args[]) { Outer outer = new Outer(); outer.displayinner();

Osztály szintű deklarációk Osztály szintű deklaráció Osztálytag Példánytag Konstruktor Osztály inicializáló blokk Példány inicializáló blokk Belső osztály Osztályváltozó Példányváltozó Osztálymetódus Példánymetódus 62/55

UML Diagram Unified Modeling Language Osztály neve Adattagok: név: típus Metódusok: konstruktor getter, setter egyéb Láthatóság: + public # protected ~ package private - private 62/56 Az UML szabványos, általános célú modellező nyelv, rendszertervezők, szoftvermérnökök számára. Az osztálydiagram a rendszerben használt osztályokat mutatja, azok attribútumaival, és kapcsolataikkal együtt.

Lokális osztály Egy metódus belsejében deklarált osztályt lokális osztálynak nevezünk 62/57 Hatásköre a beágyazó blokk végéig terjed Csakúgy mint a példányszintű tagosztály nem definiálhat statikus tagokat Eléri a beágyazó osztály azon tagjait, amelyek a függvényben elérhetőek Nem használható módosítók: public protected,private, static Használható: final A lokális osztály csak olyan lokális változókra és paraméterekre hivatkozhat, amelyek final módosítóval rendelkeznek.

Lokális osztály Példakód public class TestClass { private int data=30; 62/58 void display(){ class Local{ void msg(){system.out.println(data); Local lc = new Local(); lc.msg(); public static void main(string args[]){ TestClass x = new TestClass(); x.display(); A display metódusban deklarált Local nevű osztály egy lokális osztály, mely eléri a data adattagot.

Névtelen osztály Ha úgy deklarálunk egy osztályt, hogy nem adunk nevet neki, akkor név nélküli (anonim) belső osztályt hozunk létre. Ekkor az osztály definiálása és példányosítása egyszerre, egy helyen történik. 62/59 Mivel az anonim osztálynak nincs neve, konstruktora sem lehet. Ha szükség van konstruktorra, akkor vagy lokális osztályt kell használni, vagy inicializáló blokkot, amit pont erre a helyzetre találtak ki Szintén nem használhatóak a public, protected, private, static módosítók Akkor ajánlott használni, ha az osztályt, amit megadunk, rögtön használjuk is vagy csak egyszer kell használni, esetleg az osztálynak nagyon rövid a megvalósítása.

Névtelen osztály Példakód jrb1 = new JRadioButton("Piros"); jrb1.addactionlistener( new ActionListener() { public void actionperformed( ActionEvent e ) { if (jrb1.isselected()) szin = "Piros"; ); A { között egy névtelen osztály található, ami implementálja az actionperformed metódust. 62/60

Felhasznált irodalom Ficsor Lajos elektronikus jegyzetei Elek Tibor elektronikus jegyzetei www.tutorialspoint.com/java oldal anyagai prog.hu oldal anyagai Nyékiné G. Judit (szerk.): JAVA 2 útikalauz programozóknak, ELTE TTK Hallgatói Alapítvány, Budapest, 1999 Daniel J. Berg, J. Steven Fritzinger: JAVA felsőfokon,wiley, 1999 Joshua Bloch: Hatékony Java, 2008 62/61

VÉGE VÉGE 62/62