Java Academy · Aula

Padrões em switch

Combine tipos selados e padrões.

Aula 4 de 413 etapas

Padrões em switch é 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.

Padrões na seleção

A seleção evoluiu de comparar constantes para comparar padrões. Combinada com tipos selados e registros, uma seleção pode encaminhar por tipo, desestruturar dados e garantir cobertura completa.

Padrões de tipo na seleção

Cada caso pode ser um padrão de tipo, vinculando uma variável tipada para esse ramo.

public class Main {
    static String kind(Object o) {
        return switch (o) {
            case Integer i -> "int " + i;
            case String s -> "string " + s;
            default -> "other";
        };
    }

    public static void main(String[] args) {
        System.out.println(kind(42));
        System.out.println(kind("hi"));
        System.out.println(kind(3.14));
    }
}

Tipos selados não precisam de caso padrão

Quando o seletor é um tipo selado e você cobre todos os subtipos permitidos, a seleção é exaustiva sem um default.

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

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

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

Padrões de registro nos casos

Os casos podem desestruturar registros, expondo os componentes diretamente ao corpo do ramo.

public class Main {
    sealed interface Shape permits Circle, Rectangle {}
    record Circle(double r) implements Shape {}
    record Rectangle(double w, double h) implements Shape {}

    static double area(Shape shape) {
        return switch (shape) {
            case Circle(double r) -> Math.PI * r * r;
            case Rectangle(double w, double h) -> w * h;
        };
    }

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

Guardas com condições

Uma cláusula when adiciona uma guarda booleana a um caso. O caso só corresponde se o padrão for adequado e a guarda for verdadeira.

public class Main {
    static String size(Object o) {
        return switch (o) {
            case Integer i when i < 0 -> "negative";
            case Integer i when i == 0 -> "zero";
            case Integer i -> "positive";
            default -> "not an int";
        };
    }

    public static void main(String[] args) {
        System.out.println(size(-5));
        System.out.println(size(0));
        System.out.println(size(7));
    }
}

A ordem importa com guardas

Os casos com guardas são testados de cima para baixo. Um caso com guarda mais específico deve vir antes de um caso mais amplo sem guarda, ou o caso amplo o absorveria.

Tratamento de valores nulos

Adicione case null para tratar um seletor nulo; caso contrário, a seleção lança NullPointerException. Você pode até combiná-lo como case null, default.

public class Main {
    static String label(String s) {
        return switch (s) {
            case null -> "missing";
            case "yes" -> "affirmative";
            default -> "other: " + s;
        };
    }

    public static void main(String[] args) {
        System.out.println(label(null));
        System.out.println(label("yes"));
        System.out.println(label("maybe"));
    }
}

Padrões aninhados na seleção

Os casos podem aninhar padrões de registro para corresponder a estruturas profundas e aplicar guardas a valores internos em um único lugar.

public class Main {
    record Point(int x, int y) {}
    record Line(Point a, Point b) {}

    static String describe(Object o) {
        return switch (o) {
            case Line(Point(var x1, var y1), Point(var x2, var y2)) when x1 == x2 -> "vertical";
            case Line(Point a, Point b) -> "line";
            default -> "other";
        };
    }

    public static void main(String[] args) {
        System.out.println(describe(new Line(new Point(1, 0), new Point(1, 5))));
        System.out.println(describe(new Line(new Point(0, 0), new Point(2, 3))));
    }
}

Instruções e expressões

A seleção com padrões funciona tanto como uma expressão, produzindo um valor com -> ou yield, quanto como uma instrução. As regras de exaustividade se aplicam quando o seletor é selado.

Substituindo código de visitante

Juntos, tipos selados e seleção com padrões substituem padrões de visitante verbosos e sequências de instanceof por um encaminhamento conciso e verificado pelo compilador sobre um modelo fechado.

Um interpretador completo

Um avaliador de expressões usando um modelo selado e uma seleção com padrões.

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

    static int eval(Expr e) {
        return switch (e) {
            case Num(int v) -> v;
            case Add(Expr l, Expr r) -> eval(l) + eval(r);
            case Mul(Expr l, Expr r) -> eval(l) * eval(r);
        };
    }

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

Verificação rápida

Teste sua compreensão dos padrões na seleção.

Responda na aula interativa

Recapitulação

Você aprendeu os padrões na seleção.

Os casos podem ser padrões de tipo e padrões de registro, com desestruturação.
Seletores selados permitem seleções exaustivas sem default.
As guardas when refinam os casos; a ordem importa.
case null trata valores nulos com segurança.

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 “Padrões em switch” é grátis?

Sim — o texto completo de “Padrões em switch” é 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 “Padrões em switch”?

Combine tipos selados e padrões. 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 “Padrões em switch”?

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

Correspondência de padrões para instanceof
Padrões de registros
Padrões de registros aninhados
Padrões em switch

← Voltar para Java Academy