A beágyazott osztály egy másik osztályon belül definiált osztály. A Java négy típust tartalmaz — statikus beágyazott, belső (nem statikus), lokális és anonim — mindegyik eltérő hozzáféréssel rendelkezik a befoglaló osztályhoz és különböző felhasználási esetek.
public class Outer {
private static int data = 10;
static class Nested { // static → no reference to an Outer INSTANCE
void show() {
System.out.println(data); // can access static members of Outer only
}
}
}
Outer.Nested n = new Outer.Nested(); // created without an Outer instance
Egy static beágyazott osztály úgy viselkedik, mint egy felső szintű osztály, de a külső osztályon belül van névtérben. Nem tartalmaz hivatkozást egy külső példányra — csoportosító segédeszközökhöz használatos (pl. egy Builder, Node egy adatstruktúrában).
public class Outer {
private int value = 5;
class Inner { // non-static → has an implicit reference to Outer
void show() {
System.out.println(value); // can access Outer's INSTANCE members (even private)
}
}
}
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner(); // needs an Outer instance to create
Egy nem statikus belső osztály implicit hivatkozást tart a befoglaló példányára, így hozzáfér a külső objektum példány mezőihez. (Vigyázat: ez a hivatkozás memóriaszivárgást okozhat, ha a belső példány hosszabb ideig él, mint a külső.)
void process() {
class Helper { // local to this method
void run() { ... }
}
new Helper().run();
}
Ritka; a metódusra korlátozott.
// implement an interface/abstract class inline, for single use
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) { handleClick(); }
});
Runnable task = new Runnable() {
public void run() { System.out.println("running"); }
};
Egy anonim osztály egy egyszeri felület vagy osztály implementációja, amely egyidejűleg van definiálva és példányosítva — történelmileg gyakori az eseménykezelőkben és visszahívásokban. A modern Java gyakran ezeket lambda kifejezésekkel helyettesíti, amikor a cél egy funkcionális felület:
button.addActionListener(e -> handleClick()); // ✅ lambda — much cleaner
Runnable task = () -> System.out.println("running");
A beágyazott osztályok hasznos eszköz az olyan osztályok logikai csoportosítására, amelyek csak egy kontextusban használatosak, növelve az egységbezárást és az olvashatóságot.
A típusok megértése — különösen a statikus vagy belső megkülönböztetés (statikus = független, belső = befoglaló példányhivatkozást tartalmaz) — fontos a tervez és a hibák elkerüléséhez: a belső osztályok implicit külső hivatkozása memóriaszivárgást okozhat, és a statikus választása, amikor nincs szüksége a külső példányra, a tisztább alapértelmezés.
Az anonim osztályok a klasszikus módszer az inline implementációk biztosítására (eseménykezelők, komparátorok), és az, hogy azok nagy részben a funkcionális felületekhez tartozó lambda kifejezésekkel felváltódtak, a modern Java készültségét tükrözi.
Ezek az egész szabványos könyvtárban megjelennek (pl. a Map.Entry egy beágyazott felület, az építők statikus beágyazott osztályok), ami gyakorlati, gyakran előforduló tudássá teszi őket.