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
- Java Language Specification, Java SE 21 — §8.1.3 Inner Classes and Enclosing Instances
- Java Language Specification, Java SE 21 — §8.1.1.2 sealed, non-sealed, and final Classes
- Java Language Specification, Java SE 21 — §8.5 Member Class and Interface Declarations
- Java Language Specification, Java SE 21 — §9.1.1.3 static Interfaces
- Java Language Specification, Java SE 21 — §9.5 Member Class and Interface Declarations
- LinkedHashMap (Java SE 21 & JDK 21)
- SequencedMap (Java SE 21 & JDK 21) — pollFirstEntry()