Belső osztályok
Az előadás videója elérhető a itt.
Beágyazott osztályok¶
Osztályt definiálni lehet osztályon vagy metóduson belüli is. llyet akkor érdemes csinálni, ha logikailag is nagyon összetartozóak az osztályok. Természetesen ilyen esetben is megadhatóak láthatóságok, hogy magukat a beágyazott osztályokat hogyan lehet elérni.
Attól, hogy ezekben az esetekben az egyik osztály fizikailag tartalmazza a másikat, az nem jelenti azt, hogy ez kompozíció, ezeknek az osztályoknak az objektumait külön hozzuk általában létre. Azon túl, hogy ezekkel a beágyazott osztályokkal belső algoritmusok teljesen elrejthetőek lesznek a külvilág elől, olyan előnyökhöz is juthatunk, hogy a belső osztály objektumai elérik a külső osztály adattagjait is egyszerűen.
Amikor létrehozunk egy belső osztályt, annak már bináris neve árulkodik arról, hogy az egy másik osztályon belül lett létrehozva:
Külso$Belso.class
Belső osztályok - Példa¶
public class Csomag {
class Tartalom {
private int x = 19;
public int miVanBenne() {
return x;
}
}
class Cel {
private String cimzett;
Cel(String cimzett) {
this.cimzett = cimzett;
}
String miACim() {
return cimzett;
}
}
public void felad(String cel) {
Tartalom t = new Tartalom();
Cel c = new Cel(cel);
System.out.println(c.miACim());
}
public static void main(String[] args) {
Csomag cs = new Csomag();
cs.felad("Tanzania");
}
}
A példánkban a külső Csomag osztály tartalmaz két belső osztályt. Mindkettőt a Csomag osztályon belül példányosítjuk a felad metódusban. Így látszik, hogy ezek az objektumok konkrétan egy csomag objektumhoz kötődnek.
Belső osztályok szkópja¶
A példában is bemutatott eset az, amikor a belső osztály szkópja egy másik osztály. Ilyenkor a belső osztályból objektumot az osztályon belül hozhatunk létre (ld. példa), vagy egy objektum által.
Ha egy osztályt csak egy metóduson belül szeretnénk példányosítani, akkor talán érdemes az osztályt magában a metódusban definiálni, így csak az a metódus tudja példányosítani. Ebben az esetben az osztály objektuma a tartalmazó metódus paramétereit is elérik.
Ha csak egyetlen egy kifejezésben szeretnénk példányosítani az osztályt, akkor ezt megtehetjük az adott kifejezésben is. Ilyenkor kapjuk az anonymous osztályokat.
Részletesebb példát ezekre az esetekre majd a GUI fejezetben nézünk.
.this és .new¶
Láttuk, hogy a belső osztály objektumai függnek a külső osztály objektumaitól. Minden objektum a this pointerrel vissza tud adni egy saját magára mutató referenciát. Belső osztály objektumai esetén értelmes kérés lehet az, hogy elérjük azt a külső objektumot, amely által a belső objektum létre lett hozva. Ezt tudjuk megtenni a KulsoOsztalyNeve.this hivatkozással.
Amikor pedig a külső osztály egy objektumán keresztül szeretnénk példányosítani a belső osztályt, akkor azt a .new operátorral tudjuk megtenni:
public class Kulso {
public class Belso {
public Kulso kulso() {
return Kulso.this;
}
}
public static void main(String[] args) {
Kulso k = new Kulso();
Kulso.Belso kb = k.new Belso();
}
}
Statikus belső osztályok¶
Az előbbiekben tárgyalt belső osztályokon túl lehetőségünk van arra is, hogy a belső osztály elé odategyünk egy static módosító szót.
Ekkor a kapott osztály egyszerű statikus tagja lesz a külsőnek. Tulajdonképpen egy sima osztály a másik osztály szkópján belül. A külső osztály példányosítása nélkül is elérhető. Nem látja a külső osztály adattagjait és metódusait. Kényelmes megoldás lehet a statikus belső osztályok használata akkor, ha olyan közös kódot szeretnénk létrehozni, amelyet minden megvalósításban ugyanúgy akarunk használni. Pl. felhasználható ez tesztelésben.
public class Kulso {
static class Belso {
public void foo() {
System.out.println("Statikus belso osztaly");
}
}
public static void main(String args[]) {
Kulso.Belso b = new Kulso.Belso();
b.foo();
}
}