Hva er typene nestede klasser i Java?

Question

Accepted Answer

En **nestet klasse** er en klasse definert inne i en annen klasse. Java har fire typer — **statisk nestet**, **inner (ikke-statisk)**, **lokal**, og **anonym** — hver med forskjellig tilgang til den omsluttende klassen og ulike brukstilfeller.

## 1. Statisk nestet klasse — uavhengig av 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` nestet klasse oppfører seg som en toppnivåklasse, men er navnerommet inne i den ytre. Den holder **ikke** en referanse til en ytre instans — brukt for å gruppere hjelperklasser (f.eks. en `Builder`, `Node` i en datastruktur).

## 2. Inner (ikke-statisk) klasse — knyttet 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 ikke-statisk **inner** klasse holder en implisitt referanse til sin omsluttende instans, så den kan få tilgang til den ytre objektets instansfelter. (Advarsel: denne referansen kan forårsake **minnelekkasjer** dersom inner-instansen lever lenger enn den ytre.)

## 3. Lokal klasse — definert inne i en metode

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

Sjelden brukt; begrenset til metoden.

## 4. Anonym klasse — engangsimplementering, uten 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 **anonym** klasse er en engangsimplementering av et grensesnitt eller en klasse, definert og instansiert samtidig — historisk vanlig for event-håndterere og callbacks. Moderne Java erstattet ofte disse med **lambdaer** når målet er et funksjonelt grensesnitt:

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

## Hvorfor det betyr noe

Nestede klasser er et nyttig verktøy for å **logisk gruppere** klasser som kun brukes i en kontekst, noe som øker innkapsling og lesbarhet.

Å forstå typene — spesielt skillet **statisk-vs-inner** (statisk = uavhengig, inner = holder en referanse til den omsluttende instansen) — betyr noe både for design og for å unngå feil: inner-klassers implisitte ytre referanse kan forårsake minnelekkasjer, og å velge statisk når du ikke trenger den ytre instansen er det renere standardvalget.

Anonyme klasser var den klassiske måten å gi inline-implementeringer (event-håndterere, komparatorer), og å vite at de i stor grad er erstattet av lambdaer for funksjonelle grensesnitt reflekterer moderne Java-kompetanse.

Disse vises gjennom hele standardbiblioteket (f.eks. `Map.Entry` er et nestet grensesnitt, builders er statiske nestede klasser), noe som gjør dem til praktisk, ofte påtruffet kunnskap.