Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Clases e interfaces anidadas en Java

Distingue las clases anidadas estáticas de las clases internas, expón las etapas de un builder mediante interfaces públicas y parametriza una caché LRU anidada.

Versión: Java SE 21

Sintaxis

class Outer {
    public interface Step { Result build(); }
    private static final class Builder implements Step {
        public Result build() { return new Result(); }
    }
    public static final class Result {}
    static class LRUCache<K,V> {}
    class Inner {}
}
// Where accessible: new Outer.Result() vs. outer.new Inner()

Una clase anidada estática no tiene una instancia contenedora implícita. Desde fuera se referencia como Outer.Nested y, si el constructor es accesible, se instancia con new Outer.Nested(). Para acceder a los miembros de instancia de otro objeto de la clase contenedora, hace falta una referencia explícita a ese objeto. Si la clase anidada extiende la clase contenedora, sus métodos de instancia pueden acceder a los miembros de instancia heredados mediante su propio this implícito. En cambio, una clase miembro no estática (clase interna) tiene una instancia contenedora y puede crearse con outer.new Inner().

En static final class, static indica que no hay instancia contenedora y final impide crear subclases. Ninguno de los dos modificadores hace inmutables los objetos. En private static final class Builder, private también oculta el tipo de implementación al código cliente situado fuera de la clase contenedora.

Las interfaces anidadas son implícitamente static, pero una interfaz miembro declarada en una clase no es automáticamente public. En el ejemplo, las interfaces públicas Main.TitleStep y Main.BuildStep definen las operaciones disponibles. El tipo devuelto por builder() no expone build(); el que devuelve title(...) sí lo expone.

static class LRUCache<K,V> declara sus propios parámetros de tipo: K para claves y V para valores. No puede usar los parámetros de tipo de la clase contenedora. El ejemplo usa un LinkedHashMap ordenado por acceso. Cuando el tamaño supera el límite, pollFirstEntry() elimina la entrada a la que se accedió hace más tiempo. El método pertenece a la API de Java SE 21; la caché del ejemplo no es segura para el acceso concurrente.

Ejemplos

import java.util.LinkedHashMap;

public class Main {
    public interface TitleStep {
        BuildStep title(String title);
    }

    public interface BuildStep {
        Report build();
    }

    public static TitleStep builder() {
        return new Builder();
    }

    private static final class Builder implements TitleStep, BuildStep {
        private String title;

        @Override
        public BuildStep title(String title) {
            this.title = title;
            return this;
        }

        @Override
        public Report build() {
            return new Report(title);
        }
    }

    public static final class Report {
        private final String title;

        private Report(String title) {
            this.title = title;
        }

        public String title() {
            return title;
        }
    }

    static class LRUCache<K,V> {
        private final int limit;
        private final LinkedHashMap<K,V> entries = new LinkedHashMap<>(16, 0.75f, true);

        LRUCache(int limit) {
            if (limit < 1) {
                throw new IllegalArgumentException("limit must be positive");
            }
            this.limit = limit;
        }

        V get(K key) {
            return entries.get(key);
        }

        void put(K key, V value) {
            entries.put(key, value);
            if (entries.size() > limit) {
                entries.pollFirstEntry();
            }
        }
    }

    public static void main(String[] args) {
        Report report = Main.builder().title("Report").build();
        System.out.println(report.title());

        Main.LRUCache<String, Integer> cache = new Main.LRUCache<>(2);
        cache.put("a", 1);
        cache.put("b", 2);
        System.out.println(cache.get("a"));
        cache.put("c", 3);
        System.out.println(cache.get("b"));
    }
}

Resultado

Report
1
null

El programa no crea un objeto `Main`. Leer `a` devuelve `1` y actualiza el orden de acceso, por lo que añadir `c` elimina `b`. La lectura posterior de `b` devuelve `null`.

Lecciones relacionadas

  • Java · Lección 37 · Intermedio · Versión: 2
  • Java · Lección 38 · Intermedio · Versión: 2
  • Java · Lección 40 · Intermedio · Versión: 2

Fuentes