Hvad er typerne af nested classes i Java?

Question

Accepted Answer

En **nested class** er en klasse defineret inde i en anden klasse. Java har fire typer — **static nested**, **inner (non-static)**, **local** og **anonymous** — hver med forskellig adgang til den omsluttende klasse og forskellige use cases.

## 1. Static nested class — uafhængig af en instans

```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
```

En `static` nested class opfører sig som en top-level klasse men er namespacet inde i den ydre. Den holder **ikke** en reference til en ydre instans — bruges til at gruppere hjælpeklasser (f.eks. en `Builder`, `Node` i en datastruktur).

## 2. Inner (non-static) class — bundet til en instans

```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
```

En non-static **inner** klasse holder en implicit reference til sin omsluttende instans, så den kan få adgang til den ydre objekt's instansfelter. (Advarsel: denne reference kan forårsage **memory leaks** hvis inner-instansen overlever den ydre.)

## 3. Local class — defineret inde i en metode

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

Sjældent brugt; scopet til metoden.

## 4. Anonymous class — engangs-implementering, uden navn

```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"); }
};
```

En **anonymous** klasse er en engangs-implementering af et interface eller en klasse, defineret og instantieret på én gang — historisk almindelig for event handlers og callbacks. Moderne Java erstatter ofte disse med **lambdas** når målet er et functional interface:

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

## Hvorfor det betyder noget

Nested classes er et nyttigt værktøj til at **logisk gruppere** klasser der kun bruges i en kontekst, hvilket øger encapsulation og læsbarhed.

At forstå typerne — især **static-vs-inner-skelnen** (static = uafhængig, inner = holder en omsluttende-instans-reference) — betyder noget for både design og fejlforebyggelse: inner classes' implicit ydre reference kan forårsage memory leaks, og at vælge static når du ikke har brug for den ydre instans er det renere valg.

Anonymous classes var den klassiske måde at levere inline-implementeringer (event handlers, comparators), og at vide at de i høj grad erstattes af lambdas for functional interfaces afspejler moderne Java-kompetence.

Disse optræder gennem hele standardbiblioteket (f.eks. `Map.Entry` er et nested interface, builders er static nested classes), hvilket gør dem praktisk, hyppigt forekommende viden.