Java Academy · Aula

Expressões switch com Enumerações

Use expressões switch modernas com enumerações para criar ramificações claras e abrangentes.

Expressões switch com Enumerações é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 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.

Expressões de seleção com enumerações

Expressões de seleção (Java 14+) com enumerações oferecem encaminhamento exaustivo, conciso e baseado em tipos. Quando todas as constantes da enumeração são cobertas, nenhum default é necessário.

Instrução de seleção tradicional

A instrução de seleção clássica funciona com enumerações, mas exige break para impedir a continuação automática para o próximo caso.

enum Severity { LOW, MEDIUM, HIGH, CRITICAL }

Severity s = Severity.HIGH;
String action;
switch (s) {
    case LOW:
        action = "Log and monitor";
        break;
    case MEDIUM:
        action = "Notify on-call team";
        break;
    case HIGH:
        action = "Page engineer immediately";
        break;
    case CRITICAL:
        action = "Activate incident response";
        break;
    default:
        action = "Unknown";
}
System.out.println(action); // Page engineer immediately

Expressão de seleção com rótulos de seta

Expressões de seleção com rótulos de seta eliminam a continuação automática e o break. Elas são avaliadas como um valor e exigem exaustividade.

enum Severity { LOW, MEDIUM, HIGH, CRITICAL }

Severity s = Severity.HIGH;
String action = switch (s) {
    case LOW      -> "Log and monitor";
    case MEDIUM   -> "Notify on-call team";
    case HIGH     -> "Page engineer immediately";
    case CRITICAL -> "Activate incident response";
    // no default needed — all cases covered
};
System.out.println(action); // Page engineer immediately

Expressão de seleção com blocos

Quando a lógica do caso exige várias instruções, use um bloco com yield para produzir o valor do resultado.

enum DayOfWeek { MON, TUE, WED, THU, FRI, SAT, SUN }

DayOfWeek day = DayOfWeek.FRI;
int hoursOpen = switch (day) {
    case MON, TUE, WED, THU -> 8;
    case FRI -> {
        System.out.println("Half day on Friday!");
        yield 4;  // yield returns value from block
    }
    case SAT, SUN -> 0;
};
System.out.println("Hours open: " + hoursOpen); // Hours open: 4

Agrupando vários casos

Várias constantes de enumeração podem compartilhar o mesmo caso, separadas por vírgulas.

enum Season { SPRING, SUMMER, FALL, WINTER }

Season season = Season.SUMMER;
String activity = switch (season) {
    case SPRING, FALL -> "Hike in the mountains";
    case SUMMER       -> "Beach vacation";
    case WINTER       -> "Ski at the resort";
};
System.out.println(activity); // Beach vacation

Retornando de métodos com switch

As expressões switch funcionam muito bem como instruções de retorno em métodos, deixando a intenção clara.

enum Priority { LOW, NORMAL, HIGH, URGENT }

static int getSlaHours(Priority p) {
    return switch (p) {
        case LOW    -> 72;
        case NORMAL -> 24;
        case HIGH   -> 4;
        case URGENT -> 1;
    };
}

System.out.println(getSlaHours(Priority.URGENT)); // 1
System.out.println(getSlaHours(Priority.LOW));    // 72

Expressão switch em um fluxo

As expressões switch podem ser usadas dentro de operações de fluxo para realizar transformações limpas em cada elemento.

import java.util.*;
import java.util.stream.*;

enum Status { PENDING, ACTIVE, CLOSED }

record Account(String id, Status status) {}

List<Account> accounts = List.of(
    new Account("A1", Status.ACTIVE),
    new Account("A2", Status.PENDING),
    new Account("A3", Status.CLOSED)
);

accounts.stream()
    .map(a -> a.id() + ": " + switch (a.status()) {
        case ACTIVE  -> "\u2705 Live";
        case PENDING -> "\u23f3 Awaiting activation";
        case CLOSED  -> "\u274c Deactivated";
    })
    .forEach(System.out::println);

Exaustividade em tempo de compilação

O compilador garante que todas as constantes da enumeração sejam contempladas. Adicionar uma nova constante a uma enumeração causa erros de compilação em todas as expressões switch que não a tratam.

enum Color { RED, GREEN, BLUE }  // add YELLOW here → compile error below

Color c = Color.GREEN;
// This switch is exhaustive for RED, GREEN, BLUE
// If you add YELLOW to the enum without adding a case here,
// the compiler will report an error.
String hex = switch (c) {
    case RED   -> "#FF0000";
    case GREEN -> "#00FF00";
    case BLUE  -> "#0000FF";
};
System.out.println(hex); // #00FF00

Switch com default para segurança

Ao usar uma instrução switch, e não uma expressão, ou quando o switch cobre intencionalmente apenas alguns casos, adicione um caso default.

enum Feature { DARK_MODE, PUSH_NOTIFICATIONS, ANALYTICS, BETA_FEATURE }

static boolean isEnabled(Feature feature) {
    return switch (feature) {
        case DARK_MODE, PUSH_NOTIFICATIONS -> true;
        case ANALYTICS                     -> false;
        default -> {
            System.out.println("Unknown feature: " + feature);
            yield false;
        }
    };
}
System.out.println(isEnabled(Feature.DARK_MODE));     // true
System.out.println(isEnabled(Feature.BETA_FEATURE));  // false

Prática: ciclo de vida do pedido

Uma máquina de estados completa para o ciclo de vida de um pedido, usando uma expressão switch para determinar as transições permitidas.

enum OrderState { CART, PENDING, CONFIRMED, SHIPPED, DELIVERED, CANCELLED }

static Set<OrderState> allowedTransitions(OrderState from) {
    return switch (from) {
        case CART      -> Set.of(OrderState.PENDING, OrderState.CANCELLED);
        case PENDING   -> Set.of(OrderState.CONFIRMED, OrderState.CANCELLED);
        case CONFIRMED -> Set.of(OrderState.SHIPPED);
        case SHIPPED   -> Set.of(OrderState.DELIVERED);
        case DELIVERED, CANCELLED -> Set.of(); // terminal states
    };
}
System.out.println(allowedTransitions(OrderState.PENDING));
// [CONFIRMED, CANCELLED]

Switch com String versus enumeração

Usar switch com String exige uma verificação de nulo e diferencia maiúsculas de minúsculas. Usar switch com uma enumeração é seguro para nulos (NPE se o valor for nulo) e garante a segurança de tipos — prefira enumerações quando o conjunto de valores for conhecido.

// String switch — fragile
String role = "admin";
String label = switch (role.toLowerCase()) {
    case "admin" -> "Administrator";
    case "guest" -> "Guest User";
    default      -> "Unknown";
};

// Enum switch — type-safe
enum Role { ADMIN, GUEST }
Role r = Role.ADMIN;
String label2 = switch (r) {
    case ADMIN -> "Administrator";
    case GUEST -> "Guest User";
};
System.out.println(label2); // Administrator

Verificação rápida

Você tem uma enumeração com 4 constantes e escreve uma expressão switch que cobre as 4. O que acontece se você adicionar uma 5ª constante à enumeração?

Recapitulação: expressões switch com enumerações

Principais conclusões:

As expressões switch com rótulos de seta eliminam break e a execução em cascata
Use yield para retornar um valor de um bloco de caso
Agrupe várias constantes com vírgulas: case A, B ->
Expressões switch exaustivas não exigem default quando todas as constantes são contempladas
Adicionar uma nova constante de enumeração causa erros de compilação em expressões switch exaustivas
As expressões switch são excelentes em operações map() de fluxos

Perguntas Frequentes

A aula “Expressões switch com Enumerações” é grátis?

Sim — o texto completo de “Expressões switch com Enumerações” é 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 “Expressões switch com Enumerações”?

Use expressões switch modernas com enumerações para criar ramificações claras e abrangentes. 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 3 de 4.

Quanto tempo leva a aula “Expressões switch com Enumerações”?

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