¿Cuáles son los tipos de clases anidadas en Java?

Question

Accepted Answer

Una **clase anidada** es una clase definida dentro de otra clase. Java tiene cuatro tipos — **anidada estática**, **interna (no estática)**, **local** y **anónima** — cada una con diferente acceso a la clase envolvente y diferentes casos de uso.

## 1. Clase anidada estática — independiente de una instancia

```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 clase anidada `static` se comporta como una clase de nivel superior pero está contenida dentro de la clase externa. **No** mantiene una referencia a una instancia externa — se usa para agrupar utilidades (por ejemplo, un `Builder`, `Node` en una estructura de datos).

## 2. Clase interna (no estática) — vinculada a una instancia

```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 clase **interna** no estática mantiene una referencia implícita a su instancia envolvente, por lo que puede acceder a los campos de instancia del objeto externo. (Advertencia: esta referencia puede causar **fugas de memoria** si la instancia interna sobrevive a la externa.)

## 3. Clase local — definida dentro de un método

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

Raramente utilizada; limitada al alcance del método.

## 4. Clase anónima — implementación única sin nombre

```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 **clase anónima** es una implementación única de una interfaz o clase, definida e instanciada a la vez — históricamente común para manejadores de eventos y callbacks. Java moderno a menudo reemplaza estas con **lambdas** cuando el objetivo es una interfaz funcional:

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

## Por qué es importante

Las clases anidadas son una herramienta útil para **agrupar lógicamente** clases que se usan solo en un contexto, aumentando la encapsulación y legibilidad.

Comprender los tipos — especialmente la **distinción estática-vs-interna** (estática = independiente, interna = mantiene una referencia a la instancia envolvente) — importa tanto para el diseño como para evitar errores: la referencia implícita a la clase externa de las clases internas puede causar fugas de memoria, y elegir estática cuando no necesitas la instancia externa es la opción más limpia por defecto.

Las clases anónimas fueron la forma clásica de proporcionar implementaciones en línea (manejadores de eventos, comparadores), y saber que en gran medida son reemplazadas por lambdas para interfaces funcionales refleja dominio de Java moderno.

Estas aparecen en toda la biblioteca estándar (por ejemplo, `Map.Entry` es una interfaz anidada, los builders son clases anidadas estáticas), lo que las hace conocimiento práctico y frecuentemente encontrado.