Java Academy · Lección

Cláusula permits

Enumere los subtipos permitidos

Cláusula permits es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 2 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.

La cláusula permits

La cláusula permits es la forma en que un tipo sellado especifica sus subtipos permitidos. Aparece justo después del nombre del tipo y de la palabra clave permits.

Sintaxis básica

Enumere los subtipos permitidos separados por comas después de permits.

public class Main {
    sealed interface Vehicle permits Car, Truck, Motorcycle {}
    record Car() implements Vehicle {}
    record Truck() implements Vehicle {}
    record Motorcycle() implements Vehicle {}

    public static void main(String[] args) {
        Vehicle v = new Truck();
        System.out.println(v.getClass().getSimpleName());
    }
}

Implementación del contrato

Cada subtipo nombrado debe implements (en el caso de las interfaces) o extends (en el caso de las clases) el tipo sellado. Incluir en permits una clase que no lo haga provoca un error de compilación.

Omitir permits

Si todos los subtipos permitidos se declaran en el mismo archivo que el tipo sellado, puede omitir permits por completo. El compilador deduce la lista automáticamente.

public class Main {
    sealed interface Status {}
    record Active() implements Status {}
    record Inactive() implements Status {}

    public static void main(String[] args) {
        Status s = new Active();
        System.out.println(s.getClass().getSimpleName());
    }
}

Cuándo es necesario permits

Si los subtipos residen en archivos separados dentro del mismo paquete o módulo, debe enumerarlos explícitamente en permits. El compilador no puede deducirlos entre archivos.

El orden no importa

El orden de los nombres en permits no tiene ningún significado semántico. No afecta al comportamiento de switch ni a ningún otro aspecto; es simplemente una lista de tipos permitidos.

Una jerarquía de clases con permits

La misma cláusula funciona con clases selladas que tienen comportamiento abstracto.

public class Main {
    sealed static abstract class Node permits Leaf, Branch {
        abstract int size();
    }
    static final class Leaf extends Node {
        int size() { return 1; }
    }
    static final class Branch extends Node {
        final Node a, b;
        Branch(Node a, Node b) { this.a = a; this.b = b; }
        int size() { return a.size() + b.size(); }
    }

    public static void main(String[] args) {
        Node tree = new Branch(new Leaf(), new Branch(new Leaf(), new Leaf()));
        System.out.println("Leaves: " + tree.size());
    }
}

Olvidar un subtipo

Si una clase implementa la interfaz sellada pero falta en permits, la compilación falla con un mensaje que indica que la clase no puede extender el tipo sellado.

Los tipos permitidos son información pública

La lista de permits forma parte del contrato del tipo y se registra en el archivo de clase. Las herramientas y el compilador pueden leerla para conocer el conjunto completo de subtipos.

Combinar hijos final y sealed

Una lista de permits puede combinar modificadores: algunos hijos pueden ser final y otros sealed para continuar la jerarquía a mayor profundidad.

public class Main {
    sealed interface Shape permits Circle, Polygon {}
    record Circle(double r) implements Shape {}
    sealed interface Polygon extends Shape permits Triangle, Rectangle {}
    record Triangle() implements Polygon {}
    record Rectangle() implements Polygon {}

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

Prácticas recomendadas

Mantenga el tipo sellado y sus subtipos cerca unos de otros para facilitar la lectura. Prefiera omitir permits en jerarquías pequeñas que estén en un solo archivo y enumérelos explícitamente cuando los archivos estén separados.

Comprobación rápida

Compruebe su comprensión de la cláusula permits.

Resumen

Ha aprendido la cláusula permits.

Enumera los subtipos permitidos después del nombre del tipo sellado.
Cada tipo enumerado debe extender o implementar el tipo sellado.
Puede omitirse cuando todos los subtipos comparten el mismo archivo.
Los subtipos también pueden ser sellados para ampliar la jerarquía.

Preguntas frecuentes

¿La lección «Cláusula permits» es gratis?

Sí — el texto completo de «Cláusula permits» 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 «Cláusula permits»?

Enumere los subtipos permitidos 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 2 de 4.

¿Cuánto tiempo toma la lección «Cláusula permits»?

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