Clases internas en Java: estáticas, internas, locales y anónimas
Los cuatro tipos de clases anidadas en Java: estáticas, internas, locales y anónimas, cuándo usar cada una y cómo acceden a la clase externa, con ejemplo.
En resumen: Java permite declarar clases dentro de otras. Hay cuatro tipos: anidada estática (
static class, no necesita un objeto externo), interna (sinstatic, accede a los campos de la instancia externa), local (dentro de un método) y anónima (sin nombre, creada en una expresión). Úsalas para tipos que solo tienen sentido junto a otra clase. Por defecto, prefiere la estática: es más simple y no retiene a la clase externa en memoria. Probado con Java 25, compatible desde Java 17.
Vídeo explicativo
Los cuatro tipos en un ejemplo
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
class Biblioteca implements Iterable<String> {
private final String[] libros = {"Clean Code", "Effective Java", "Refactoring"};
// Clase interna (no estática): accede a los campos de la instancia externa
private class LibroIterator implements Iterator<String> {
private int pos = 0;
@Override
public boolean hasNext() {
return pos < libros.length;
}
@Override
public String next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
return libros[pos++];
}
}
@Override
public Iterator<String> iterator() {
return new LibroIterator();
}
// Clase anidada estática: no necesita una Biblioteca para existir
static class Estadisticas {
static int contar(Biblioteca b) {
int n = 0;
for (String ignored : b) {
n++;
}
return n;
}
}
}
public class Main {
public static void main(String[] args) {
Biblioteca biblioteca = new Biblioteca();
for (String libro : biblioteca) {
System.out.println("Libro: " + libro);
}
System.out.println("Total: " + Biblioteca.Estadisticas.contar(biblioteca));
// Clase local: definida dentro de un método
class Saludo {
String para(String nombre) {
return "Hola, " + nombre;
}
}
System.out.println(new Saludo().para("Ana"));
// Clase anónima frente a lambda
Comparator<String> porLongitud = new Comparator<>() {
@Override
public int compare(String a, String b) {
return Integer.compare(a.length(), b.length());
}
};
List<String> ordenados = List.of("Refactoring", "Java", "Spring").stream()
.sorted(porLongitud).toList();
System.out.println("Anónima: " + ordenados);
System.out.println("Lambda: " + List.of("Refactoring", "Java", "Spring").stream()
.sorted(Comparator.comparingInt(String::length)).toList());
}
}
Salida:
Libro: Clean Code
Libro: Effective Java
Libro: Refactoring
Total: 3
Hola, Ana
Anónima: [Java, Spring, Refactoring]
Lambda: [Java, Spring, Refactoring]
LibroIterator lee el array libros de la biblioteca sin que se lo pasemos: una clase interna guarda una referencia oculta a su objeto externo.
Comparación
| Tipo | Declaración | ¿Accede a la instancia externa? | Se crea con | Uso típico |
|---|---|---|---|---|
| Anidada estática | static class X | No (solo a miembros static) | new Externa.X() | Builders, nodos, DTOs auxiliares |
| Interna | class X dentro de la clase | Sí | externa.new X() o desde la propia instancia | Iteradores, vistas de los datos internos |
| Local | class X dentro de un método | Sí, y a variables efectivamente finales | new X() en ese método | Lógica auxiliar de un solo método |
| Anónima | new Interfaz() { ... } | Igual que la local | En la misma expresión | Implementaciones de un solo uso |
Cuándo usar cada una
- Anidada estática: la opción por defecto. El patrón Builder es el ejemplo clásico (
Pizza.Builder). - Interna: cuando de verdad necesita el estado del objeto externo, como el iterador del ejemplo. Cuidado: mientras la interna exista, mantiene viva la externa, una fuente típica de fugas de memoria.
- Local: rara vez; si crece, sácala a una clase normal o a un record local.
- Anónima: casi siempre la sustituye una lambda si la interfaz tiene un solo método. Sigue siendo útil cuando necesitas varios métodos o estado propio. Tienes más en clases anónimas en Java.
Detalles del lenguaje
- Desde una interna,
Biblioteca.thises la instancia externa;thisa secas es la interna. Lo vemos en this en Java. - Las clases locales y anónimas solo pueden usar variables del método que no cambien después de asignarse (efectivamente finales), igual que las lambdas.
- Desde Java 16 las clases internas pueden declarar miembros
static. - El compilador genera un
.classpor cada una:Biblioteca$LibroIterator.class,Main$1.classpara la anónima.
Preguntas frecuentes
¿Por qué mi clase interna da error al crearla desde main?
Porque main es estático y no hay instancia externa. O la creas con externa.new Interna() o, mejor, la declaras static.
¿Las clases anidadas pueden ser privadas?
Sí, y es lo habitual cuando solo las usa la clase externa, como LibroIterator. Una clase de primer nivel solo puede ser public o de paquete.
¿Qué diferencia hay con un paquete?
Un paquete agrupa clases relacionadas; una clase anidada expresa que un tipo pertenece a otro y comparte su acceso a miembros privados.
Sigue aprendiendo
Clases anidadas, lambdas e interfaces funcionales se trabajan en el curso de Java intermedio. Sigue con static en Java y expresiones lambda.
Newsletter Semanal de Java
Cada viernes recibe lo más nuevo del ecosistema Java: frameworks, herramientas y mejores prácticas.
Sin spam. Cancela cuando quieras.