Java Academy · Aula

switch exaustivo sobre tipos selados

Completude verificada em tempo de compilação.

Aula 4 de 413 etapas

switch exaustivo sobre tipos selados é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Seleção Exaustiva

Quando você usa switch sobre um tipo selado, o compilador conhece todos os subtipos permitidos. Se sua seleção abranger todos eles, ela será exaustiva e você não precisará de um ramo padrão.

Uma Seleção com Padrão de Tipo

As expressões de seleção podem corresponder ao tipo em tempo de execução de um valor selado usando padrões de tipo.

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

    static String describe(Shape s) {
        return switch (s) {
            case Circle c -> "circle r=" + c.radius();
            case Square sq -> "square s=" + sq.side();
        };
    }

    public static void main(String[] args) {
        System.out.println(describe(new Circle(2)));
        System.out.println(describe(new Square(3)));
    }
}

Nenhum Padrão Necessário

Como Circle e Square são os únicos subtipos permitidos, o compilador aceita a seleção como completa. Adicionar um default seria redundante.

Completude em Tempo de Compilação

Se você adicionar um novo subtipo permitido posteriormente e esquecer de tratá-lo, toda seleção exaustiva falhará na compilação. Isso transforma uma classe inteira de erros em tempo de execução em erros de compilação.

Calculando um Resultado

Expressões de seleção exaustivas são ótimas para reduzir um valor a um resultado, como area.

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

    static double area(Shape s) {
        return switch (s) {
            case Circle c -> Math.PI * c.radius() * c.radius();
            case Square sq -> sq.side() * sq.side();
        };
    }

    public static void main(String[] args) {
        System.out.printf("%.2f%n", area(new Circle(1)));
        System.out.printf("%.2f%n", area(new Square(2)));
    }
}

Instruções de Seleção versus Expressões

A exaustividade se aplica a expressões de seleção (aquelas que produzem um valor) e a instruções de seleção que usam a forma de seta em um tipo selado. O compilador exige a cobertura completa.

Lidando com Nulos

Por padrão, uma seleção sobre uma referência lança NullPointerException se o valor for nulo. Você pode adicionar um rótulo case null para tratá-lo explicitamente.

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

    static String describe(Shape s) {
        return switch (s) {
            case null -> "no shape";
            case Circle c -> "circle";
            case Square sq -> "square";
        };
    }

    public static void main(String[] args) {
        System.out.println(describe(null));
        System.out.println(describe(new Circle(1)));
    }
}

Guardas Não Rompem a Exaustividade

Você pode adicionar guardas when para refinar os casos, mas um caso com guarda, sozinho, não faz com que um tipo seja considerado coberto. Você ainda precisa de um caso sem guarda para cada subtipo, a fim de manter a exaustividade.

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

    static String size(Shape s) {
        return switch (s) {
            case Circle c when c.radius() > 10 -> "big circle";
            case Circle c -> "small circle";
            case Square sq -> "square";
        };
    }

    public static void main(String[] args) {
        System.out.println(size(new Circle(20)));
        System.out.println(size(new Circle(2)));
    }
}

Selecionando sobre uma Classe Selada

A mesma exaustividade funciona para classes seladas, não apenas para interfaces.

public class Main {
    sealed static abstract class Token permits Word, Number {}
    static final class Word extends Token { final String text; Word(String t){text=t;} }
    static final class Number extends Token { final int value; Number(int v){value=v;} }

    static String show(Token t) {
        return switch (t) {
            case Word w -> "word:" + w.text;
            case Number n -> "num:" + n.value;
        };
    }

    public static void main(String[] args) {
        System.out.println(show(new Word("hi")));
        System.out.println(show(new Number(7)));
    }
}

Por Que Isso É Poderoso

A seleção exaustiva combinada com tipos selados produz código seguro e evolutivo. O conjunto de casos é documentado em um único lugar, e o compilador garante que você nunca deixe um caso de fora quando o modelo crescer.

Um Exemplo Completo

Aqui, um tipo de resultado selado é transformado em uma mensagem com cobertura completa.

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

    static String render(Result r) {
        return switch (r) {
            case Ok ok -> "value = " + ok.value();
            case Err err -> "error: " + err.message();
        };
    }

    public static void main(String[] args) {
        System.out.println(render(new Ok(10)));
        System.out.println(render(new Err("bad input")));
    }
}

Verificação Rápida

Teste sua compreensão sobre seleção exaustiva.

Responda na aula interativa

Recapitulação

Você aprendeu sobre seleção exaustiva em tipos selados.

Abranger todos os subtipos permitidos torna a seleção exaustiva, portanto não é necessário usar default.
Esquecer um novo subtipo se torna um erro de compilação.
case null trata nulos explicitamente.
As guardas refinam, mas não substituem, um caso sem guarda.

Grátis para começar

Aprenda Java com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 104
Aulas: 374

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “switch exaustivo sobre tipos selados” é grátis?

Sim — o texto completo de “switch exaustivo sobre tipos selados” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “switch exaustivo sobre tipos selados”?

Completude verificada em tempo de compilação. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “switch exaustivo sobre tipos selados”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy