Vilka är typerna av kapslade klasser i Java?

Question

Accepted Answer

En **kapslade klass** är en klass definierad inuti en annan klass. Java har fyra typer — **statisk kapslad**, **inre (icke-statisk)**, **lokal** och **anonym** — var och en med olika åtkomst till den omslutande klassen och olika användarfall.

## 1. Statisk kapslad klass — oberoende 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` kapslad klass beter sig som en toppnivåklass men är namngivningsomfattad inuti den yttre. Den **innehåller inte** en referens till en yttre instans — används för att gruppera hjälpfunktioner (t.ex. en `Builder`, `Node` i en datastruktur).

## 2. Inre (icke-statisk) klass — knuten till 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 icke-statisk **inre** klass innehåller en implicit referens till sin omslutande instans, så den kan komma åt den yttre objektets instansfält. (Försiktighet: denna referens kan orsaka **minneslekage** om den inre instansen lever längre än den yttre.)

## 3. Lokal klass — definierad inuti en metod

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

Sällan använd; begränsad till metoden.

## 4. Anonym klass — engångsimplementering, utan namn

```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** klass är en engångsimplementering av ett gränssnitt eller en klass, definierad och instansierad samtidigt — historiskt vanlig för händelsehanterare och callbacks. Modern Java ersätter ofta dessa med **lambdor** när målet är ett funktionellt gränssnitt:

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

## Varför det spelar roll

Kapslade klasser är ett användbart verktyg för att **logiskt gruppera** klasser som endast används i en kontext, vilket ökar inkapsling och läsbarhet.

Att förstå typerna — särskilt **statisk-kontra-inre-skillnaden** (statisk = oberoende, inre = innehåller en omslutande-instansreferens) — är viktig för både design och för att undvika buggar: inre klassers implicita yttre referens kan orsaka minneslekage, och att välja statisk när du inte behöver den yttre instansen är det renare standardvalet.

Anonyma klasser var det klassiska sättet att tillhandahålla inline-implementeringar (händelsehanterare, komparatörer), och att veta att de i stort sett ersatts av lambdor för funktionella gränssnitt återspeglar modern Java-kompetens.

Dessa förekommer genomgående i standardbiblioteket (t.ex. `Map.Entry` är ett kapslat gränssnitt, builders är statiska kapslade klasser), vilket gör dem till praktisk, ofta förekommande kunskap.