Java Academy · Lección

Tipos sellados con records

Modele jerarquías cerradas

Tipos sellados con records es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 3 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.

Tipos sellados y registros

Las interfaces selladas y los registros forman una combinación perfecta. La interfaz sellada define un conjunto cerrado de casos; cada registro es un caso concreto e inmutable. Juntos permiten modelar tipos de datos algebraicos.

Los registros son implícitamente final

Un registro es automáticamente final, por lo que cumple la regla de que los subtipos permitidos deben ser final, sealed o non-sealed. No se necesita ningún modificador adicional.

Una jerarquía cerrada de formas

Modele las formas como registros que implementen una interfaz sellada, cada uno con sus propios datos.

public class Main {
    sealed interface Shape permits Circle, Rectangle {}
    record Circle(double radius) implements Shape {}
    record Rectangle(double width, double height) implements Shape {}

    public static void main(String[] args) {
        Shape s = new Rectangle(3, 4);
        System.out.println(s);
    }
}

Añadir comportamiento

La interfaz sellada puede declarar métodos que todos los registros implementen, lo que proporciona polimorfismo sobre el conjunto cerrado.

public class Main {
    sealed interface Shape permits Circle, Rectangle {
        double area();
    }
    record Circle(double radius) implements Shape {
        public double area() { return Math.PI * radius * radius; }
    }
    record Rectangle(double width, double height) implements Shape {
        public double area() { return width * height; }
    }

    public static void main(String[] args) {
        Shape s = new Circle(2);
        System.out.printf("Area: %.2f%n", s.area());
    }
}

equals y toString automáticos

Los registros generan automáticamente equals, hashCode y toString. Dos registros con los mismos componentes son iguales, lo que resulta ideal para modelar valores.

public class Main {
    sealed interface Shape permits Circle {}
    record Circle(double radius) implements Shape {}

    public static void main(String[] args) {
        Circle a = new Circle(5);
        Circle b = new Circle(5);
        System.out.println(a.equals(b));
        System.out.println(a);
    }
}

Modelar resultados

Un patrón habitual consiste en un tipo de resultado sellado con un registro para el éxito y otro para el error, sustituyendo los retornos anulables o las excepciones en los resultados esperados.

public class Main {
    sealed interface Result permits Ok, Err {}
    record Ok(int value) implements Result {}
    record Err(String message) implements Result {}

    static Result parse(String s) {
        try { return new Ok(Integer.parseInt(s)); }
        catch (NumberFormatException e) { return new Err("bad number: " + s); }
    }

    public static void main(String[] args) {
        System.out.println(parse("42"));
        System.out.println(parse("oops"));
    }
}

Constructores compactos para la validación

Los registros pueden validar sus entradas en un constructor compacto, de modo que cada caso sea correcto desde su creación.

public class Main {
    sealed interface Shape permits Circle {}
    record Circle(double radius) implements Shape {
        Circle {
            if (radius < 0) throw new IllegalArgumentException("radius must be >= 0");
        }
    }

    public static void main(String[] args) {
        try { new Circle(-1); }
        catch (IllegalArgumentException e) { System.out.println(e.getMessage()); }
    }
}

Modelos de datos recursivos

Como un registro puede hacer referencia a la interfaz sellada, puede crear estructuras recursivas, como árboles de expresiones o listas enlazadas.

public class Main {
    sealed interface Expr permits Num, Add {}
    record Num(int value) implements Expr {}
    record Add(Expr left, Expr right) implements Expr {}

    public static void main(String[] args) {
        Expr e = new Add(new Num(1), new Add(new Num(2), new Num(3)));
        System.out.println(e);
    }
}

Ventajas de la inmutabilidad

Los registros son inmutables superficialmente, por lo que una jerarquía sellada de registros es fácil de entender, segura para compartir y adecuada para la concurrencia. No es necesario copiar defensivamente los registros.

Combinar con switch

Los registros sellados destacan con switch de coincidencia de patrones: cada caso puede desestructurar un registro y el compilador comprueba que se hayan cubierto todos los casos. Esto se explora en el curso de patrones.

Un cálculo sobre el modelo

Puede escribir un intérprete como un método que recorra el árbol recursivo de registros.

public class Main {
    sealed interface Expr permits Num, Add {}
    record Num(int value) implements Expr {}
    record Add(Expr left, Expr right) implements Expr {}

    static int eval(Expr e) {
        if (e instanceof Num n) return n.value();
        Add a = (Add) e;
        return eval(a.left()) + eval(a.right());
    }

    public static void main(String[] args) {
        Expr e = new Add(new Num(4), new Add(new Num(5), new Num(6)));
        System.out.println(eval(e));
    }
}

Comprobación rápida

Compruebe su comprensión de los registros sellados.

Resumen

Ha aprendido a combinar tipos sellados con registros.

Los registros son implícitamente final, por lo que encajan como subtipos permitidos.
La interfaz sellada puede declarar métodos compartidos.
Los registros proporcionan automáticamente igualdad, cálculo de hash y toString.
Juntos permiten modelar datos cerrados, inmutables y posiblemente recursivos.

Preguntas frecuentes

¿La lección «Tipos sellados con records» es gratis?

Sí — el texto completo de «Tipos sellados con records» 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 «Tipos sellados con records»?

Modele jerarquías cerradas 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 3 de 4.

¿Cuánto tiempo toma la lección «Tipos sellados con records»?

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

← Volver a Java Academy