Clases anidadas estáticas
Defina clases anidadas estáticas como tipos auxiliares asociados sin una referencia a una instancia de la clase contenedora.
Clases anidadas estáticas es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.
Clases anidadas estáticas
Una clase anidada estática se define dentro de otra clase mediante la palabra clave static. No tiene una referencia a la instancia de la clase externa; simplemente está agrupada lógicamente con ella.
Declaración de una clase anidada estática
Utilice el nombre de la clase externa para acceder a la clase anidada desde fuera.
class LinkedList<T> {
private Node<T> head;
// Static nested class — no outer instance reference
private static class Node<T> {
T data;
Node<T> next;
Node(T data) { this.data = data; }
}
public void addFirst(T item) {
Node<T> node = new Node<>(item);
node.next = head;
head = node;
}
}Acceso desde fuera
Haga referencia a una clase anidada estática pública como OuterClass.InnerClass.
class Builder {
public static class Config {
public final String host;
public final int port;
Config(String host, int port) {
this.host = host; this.port = port;
}
}
}
Builder.Config config = new Builder.Config("localhost", 8080);
System.out.println(config.host + ":" + config.port); // localhost:8080Clase anidada estática frente a clase interna
La diferencia clave es que las clases anidadas estáticas NO tienen una referencia implícita a la instancia externa. Las clases internas (no estáticas) SÍ tienen esa referencia.
class Outer {
private int x = 10;
// Static nested: no access to x
static class StaticNested {
void doSomething() {
// System.out.println(x); // compile error — no outer reference!
System.out.println("Static nested");
}
}
// Inner class: has access to x
class Inner {
void doSomething() {
System.out.println(x); // 10 — can access outer fields
}
}
}Patrón Builder con una clase anidada estática
El patrón Builder clásico utiliza una clase anidada estática para que el código que realiza la llamada no necesite una instancia externa para crear un builder.
class Pizza {
private final String size, crust;
private final List<String> toppings;
private Pizza(Builder b) {
this.size = b.size; this.crust = b.crust; this.toppings = List.copyOf(b.toppings);
}
public static class Builder {
private String size = "medium", crust = "thin";
private List<String> toppings = new ArrayList<>();
public Builder size(String s) { this.size = s; return this; }
public Builder crust(String c) { this.crust = c; return this; }
public Builder topping(String t) { this.toppings.add(t); return this; }
public Pizza build() { return new Pizza(this); }
}
}Entrada en los mapas
Map.Entry es una interfaz anidada estática conocida que se utiliza para iterar sobre pares clave-valor.
import java.util.*;
Map<String, Integer> scores = Map.of("Alice", 95, "Bob", 87, "Carol", 92);
for (Map.Entry<String, Integer> entry : scores.entrySet()) {
System.out.printf("%-10s: %d%n", entry.getKey(), entry.getValue());
}
// Modern: using var
for (var entry : scores.entrySet()) {
System.out.println(entry.getKey() + " -> " + entry.getValue());
}Pruebas con una clase anidada estática
En las pruebas unitarias, una clase anidada estática puede contener accesorios de prueba o implementaciones simuladas limitadas a la clase de prueba.
class UserServiceTest {
// Static nested fake/stub — no outer instance needed
static class FakeUserRepository implements UserRepository {
private final Map<Long, User> store = new HashMap<>();
public void save(User u) { store.put(u.id(), u); }
public Optional<User> findById(long id) {
return Optional.ofNullable(store.get(id));
}
}
// @Test methods use FakeUserRepository
void testFindUser() {
FakeUserRepository repo = new FakeUserRepository();
// ...
}
}Clases anidadas estáticas para la lógica de dominio
Agrupe tipos relacionados mediante clases anidadas estáticas para mejorar la organización en los modelos de dominio.
class Order {
private final long id;
private final List<LineItem> items;
// Static nested — logically belongs to Order, no outer reference needed
public static class LineItem {
public final String sku;
public final int quantity;
public final double unitPrice;
public LineItem(String sku, int qty, double price) {
this.sku = sku; this.quantity = qty; this.unitPrice = price;
}
public double total() { return quantity * unitPrice; }
}
// ...
}Comparación: anidada estática frente a nivel superior
Prefiera una clase anidada estática cuando una clase se utilice únicamente en el contexto de la clase externa. Utilice una clase de nivel superior cuando tenga una aplicabilidad más amplia.
Clases anidadas estáticas con genéricos
Las clases anidadas estáticas participan en los genéricos igual que las clases de nivel superior.
class Pair<A, B> {
// Static nested with its own type params
public static class Mutable<X, Y> {
public X first;
public Y second;
public Mutable(X first, Y second) {
this.first = first; this.second = second;
}
}
public static <X, Y> Mutable<X, Y> mutableOf(X x, Y y) {
return new Mutable<>(x, y);
}
}
Pair.Mutable<String, Integer> p = Pair.mutableOf("Alice", 30);
System.out.println(p.first + " is " + p.second); // Alice is 30Eficiencia de memoria
Las clases anidadas estáticas no mantienen una referencia a la instancia externa. Esto evita conservar accidentalmente el objeto externo en memoria, lo que puede provocar fugas de memoria en estructuras de larga duración.
Comprobación rápida
¿Qué diferencia una clase anidada estática de una clase interna (no estática)?
Repaso: clases anidadas estáticas
Conceptos clave:
- Las clases anidadas estáticas se agrupan con la clase externa, pero no tienen una referencia a su instancia externa
- Acceso desde fuera: OuterClass.NestedClass
- La ausencia de una referencia implícita evita conservar accidentalmente la instancia externa en memoria
- El patrón Builder suele utilizar una clase Builder anidada estática
- Map.Entry es una conocida interfaz anidada estática
- Prefiera una clase anidada estática cuando la clase interna no necesite acceder a la instancia externa
Preguntas frecuentes
¿La lección «Clases anidadas estáticas» es gratis?
Sí — el texto completo de «Clases anidadas estáticas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Clases anidadas estáticas»?
Defina clases anidadas estáticas como tipos auxiliares asociados sin una referencia a una instancia de la clase contenedora. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Java Academy?
No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «Clases anidadas estáticas»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Java Academy?
Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Clases anidadas estáticas
- Clases internas y acceso a la clase externa
- Clases locales y anónimas
- Elección de la estrategia de anidamiento adecuada