Een geneste klasse is een klasse die in een andere klasse is gedefinieerd. Java heeft vier soorten — static geneste, inner (niet-statisch), lokaal en anoniem — elk met ander toegang tot de omsluitende klasse en verschillende use cases.
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
Een static geneste klasse gedraagt zich als een top-level klasse maar is namespaced in de buitenste. Het bevat niet een referentie naar een buiteninstantie — gebruikt voor groepering van helpers (bijv. een Builder, Node in een gegevensstructuur).
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
Een niet-statische inner klasse bevat een impliciete referentie naar zijn omsluitende instantie, dus het kan toegang krijgen tot de instantievelden van het buitenobject. (Voorzichtigheid: deze referentie kan geheugenlekken veroorzaken als de inner-instantie langer leeft dan de buitenste.)
void process() {
class Helper { // local to this method
void run() { ... }
}
new Helper().run();
}
Zelden gebruikt; bereikt tot de methode.
// 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"); }
};
Een anonieme klasse is een eenmalige implementatie van een interface of klasse, gedefinieerd en geïnstantieerd in één keer — historisch veel gebruikt voor event handlers en callbacks. Modernes Java vervangt deze vaak door lambdas wanneer het doel een functionele interface is:
button.addActionListener(e -> handleClick()); // ✅ lambda — much cleaner
Runnable task = () -> System.out.println("running");
Geneste klassen zijn een handig hulpmiddel voor logische groepering van klassen die slechts in één context worden gebruikt, waardoor encapsulatie en leesbaarheid toenemen.
Het begrijpen van de soorten — vooral het static-versus-inner onderscheid (static = onafhankelijk, inner = bevat een omsluitende-instantie referentie) — is belangrijk voor zowel ontwerp als het voorkomen van bugs: de impliciete buitenreferentie van inner klassen kan geheugenlekken veroorzaken, en het kiezen van static wanneer je de buiteninstantie niet nodig hebt, is de schonere standaard.
Anonieme klassen waren de klassieke manier om inline-implementaties te bieden (event handlers, comparators), en weten dat ze grotendeels worden vervangen door lambdas voor functionele interfaces weerspiegelt moderne Java-vaardigheid.
Ze verschijnen overal in de standaardbibliotheek (bijv. Map.Entry is een geneste interface, builders zijn static geneste klassen), waardoor ze praktische, regelmatig voorkomende kennis zijn.
Een bibliotheek met IT-sollicitatievragen met gedetailleerde antwoorden — van Junior tot Senior.
Doneren