Java Academy · Lección

Declaración de tipos sellados

Restrinja quién puede extender un tipo

Declaración de tipos sellados 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.

Qué son los tipos sellados

Una clase o interfaz sellada restringe qué otros tipos pueden extenderla o implementarla. Esto permite modelar un conjunto cerrado de posibilidades sobre el que el compilador puede razonar.

El problema que resuelve

Cualquier persona puede crear subclases de una clase public normal desde cualquier lugar. A veces necesita exactamente tres formas o dos tipos de pago, sin sorpresas. El sellado hace que esa intención sea explícita y obligatoria.

La palabra clave sealed

Marque un tipo como sealed y enumere sus subtipos permitidos con permits. Cada subtipo permitido debe declarar su propio modificador de herencia.

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

    public static void main(String[] args) {
        Shape s = new Circle(2.0);
        System.out.println(s);
    }
}

Modificadores de los subtipos

Cada subtipo permitido debe ser uno de los siguientes: final (sin más subclases), sealed (continúa la restricción) o non-sealed (vuelve a permitir la extensión libre). Los registros son implícitamente final.

Una subclase final

Marcar una subclase como final cierra la jerarquía en esa rama.

public class Main {
    sealed interface Animal permits Dog, Cat {}
    static final class Dog implements Animal {
        public String toString() { return "Dog"; }
    }
    static final class Cat implements Animal {
        public String toString() { return "Cat"; }
    }

    public static void main(String[] args) {
        Animal a = new Dog();
        System.out.println(a);
    }
}

Una subclase non-sealed

Un subtipo non-sealed vuelve a permitir deliberadamente la extensión, de modo que clases desconocidas puedan extenderlo otra vez. Utilícelo con moderación cuando una rama deba permanecer abierta.

public class Main {
    sealed interface Plugin permits CorePlugin, ExternalPlugin {}
    static final class CorePlugin implements Plugin {}
    static non-sealed class ExternalPlugin implements Plugin {}
    static class ThirdParty extends ExternalPlugin {}

    public static void main(String[] args) {
        Plugin p = new ThirdParty();
        System.out.println(p.getClass().getSimpleName());
    }
}

También las clases selladas

El sellado no se limita a las interfaces. Una sealed class abstracta funciona del mismo modo y puede contener estado y comportamiento compartidos.

public class Main {
    sealed static abstract class Expr permits Num, Add {}
    static final class Num extends Expr {
        final int value;
        Num(int value) { this.value = value; }
    }
    static final class Add extends Expr {
        final Expr left, right;
        Add(Expr left, Expr right) { this.left = left; this.right = right; }
    }

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

El mismo módulo o paquete

Los subtipos permitidos deben estar en el mismo módulo que el tipo sellado o, si el código no es modular, en el mismo paquete. Esto mantiene unido y verificable el conjunto cerrado.

Aplicación por parte del compilador

Si una clase intenta extender un tipo sellado sin estar incluida en permits, el código no se compila. El conjunto cerrado queda garantizado en tiempo de compilación.

Por qué es importante

Como el compilador conoce todos los subtipos, puede verificar que un switch sobre el tipo sellado gestione todos los casos. Esta es la base de la coincidencia exhaustiva de patrones, que se aborda en un curso posterior.

Una jerarquía completa

A continuación se muestra una pequeña jerarquía cerrada utilizada como modelo de valores.

public class Main {
    sealed interface Json permits JsonNull, JsonNumber, JsonString {}
    record JsonNull() implements Json {}
    record JsonNumber(double value) implements Json {}
    record JsonString(String value) implements Json {}

    public static void main(String[] args) {
        Json[] values = { new JsonNull(), new JsonNumber(3.5), new JsonString("hi") };
        for (Json j : values) {
            System.out.println(j);
        }
    }
}

Comprobación rápida

Compruebe su comprensión de las declaraciones selladas.

Resumen

Ha aprendido a declarar tipos sellados.

sealed restringe quién puede extender o implementar un tipo.
La cláusula permits enumera los subtipos permitidos.
Cada subtipo debe ser final, sealed o non-sealed.
Los subtipos residen en el mismo módulo o paquete, y el compilador hace cumplir estas reglas.

Preguntas frecuentes

¿La lección «Declaración de tipos sellados» es gratis?

Sí — el texto completo de «Declaración de tipos sellados» 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 «Declaración de tipos sellados»?

Restrinja quién puede extender un tipo 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 «Declaración de tipos sellados»?

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