Wat zijn de soorten geneste klassen in Java?

Question

Accepted Answer

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.

## 1. Static geneste klasse — onafhankelijk van een instantie

```java
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).

## 2. Inner (niet-statische) klasse — gebonden aan een instantie

```java
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.)

## 3. Lokale klasse — gedefinieerd in een methode

```java
void process() {
    class Helper {                    // local to this method
        void run() { ... }
    }
    new Helper().run();
}
```

Zelden gebruikt; bereikt tot de methode.

## 4. Anonieme klasse — eenmalige implementatie, geen naam

```java
// 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:

```java
button.addActionListener(e -> handleClick());   // ✅ lambda — much cleaner
Runnable task = () -> System.out.println("running");
```

## Waarom het belangrijk is

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.