Quali sono i tipi di classi annidate in Java?

Question

Accepted Answer

Una **classe annidata** è una classe definita all'interno di un'altra classe. Java ha quattro tipi — **static nested**, **inner (non-static)**, **local**, e **anonymous** — ognuno con accesso diverso alla classe esterna e diversi casi d'uso.

## 1. Static nested class — indipendente da un'istanza

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

Una classe `static` nested si comporta come una classe top-level ma è organizzata nello spazio dei nomi di quella esterna. **Non** mantiene un riferimento a un'istanza esterna — usata per raggruppare helper (ad es. un `Builder`, `Node` in una struttura dati).

## 2. Inner (non-static) class — legata a un'istanza

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

Una classe **inner** non-static mantiene un riferimento implicito alla sua istanza esterna, quindi può accedere ai campi di istanza dell'oggetto esterno. (Attenzione: questo riferimento può causare **memory leak** se l'istanza inner sopravvive all'istanza esterna.)

## 3. Local class — definita all'interno di un metodo

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

Raramente usata; con scope limitato al metodo.

## 4. Anonymous class — implementazione una-tantum, senza nome

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

Una classe **anonymous** è un'implementazione una-sola di un'interfaccia o classe, definita e istanziata contemporaneamente — storicamente comune per event handler e callback. Il Java moderno spesso le rimpiazza con **lambda** quando il target è un'interfaccia funzionale:

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

## Perché è importante

Le classi annidate sono uno strumento utile per **raggruppare logicamente** classi che sono usate solo in un contesto, aumentando l'incapsulamento e la leggibilità.

Comprendere i tipi — in particolare la **distinzione static-vs-inner** (static = indipendente, inner = mantiene un riferimento all'istanza esterna) — è importante sia per il design che per evitare bug: il riferimento implicito all'istanza esterna delle classi inner può causare memory leak, e scegliere static quando non hai bisogno dell'istanza esterna è la scelta più pulita per default.

Le classi anonymous erano il modo classico per fornire implementazioni inline (event handler, comparator), e sapere che sono largamente sostituite dalle lambda per le interfacce funzionali riflette la competenza moderna di Java.

Queste appaiono in tutta la libreria standard (ad es. `Map.Entry` è un'interfaccia annidata, i builder sono classi static nested), rendendole conoscenza pratica e frequentemente incontrata.