Artículo

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 (sin static, 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

TipoDeclaración¿Accede a la instancia externa?Se crea conUso típico
Anidada estáticastatic class XNo (solo a miembros static)new Externa.X()Builders, nodos, DTOs auxiliares
Internaclass X dentro de la claseSíexterna.new X() o desde la propia instanciaIteradores, vistas de los datos internos
Localclass X dentro de un métodoSí, y a variables efectivamente finalesnew X() en ese métodoLógica auxiliar de un solo método
Anónimanew Interfaz() { ... }Igual que la localEn la misma expresiónImplementaciones 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.this es la instancia externa; this a 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 .class por cada una: Biblioteca$LibroIterator.class, Main$1.class para 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.

clases internas inner class clases anidadas java clases anónimas

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.

Compartir artículo