Java 26: Switch moderno na prática (expressões e pattern matching)

Se você ainda usa switch assim:

switch (status) {
    case 1:
        result = "ATIVO";
        break;
    case 2:
        result = "INATIVO";
        break;
    default:
        result = "DESCONHECIDO";
}

👉 isso já ficou pra trás

Java evoluiu e trouxe um switch mais moderno, funcional e seguro.

Switch como expressão (sem variável mutável)

Antes:

String result;

switch (status) {
    case 1:
        result = "ATIVO";
        break;
    case 2:
        result = "INATIVO";
        break;
    default:
        result = "DESCONHECIDO";
}

Agora:

String result = switch (status) {
    case 1 -> "ATIVO";
    case 2 -> "INATIVO";
    default -> "DESCONHECIDO";
};

👉 mais limpo 👉 menos erro 👉 sem variável mutável

Múltiplos casos no mesmo bloco

String tipo = switch (status) {
    case 1, 2 -> "ATIVO";
    case 3, 4 -> "PENDENTE";
    default -> "OUTRO";
};

👉 elimina repetição 👉 código mais direto

Bloco com lógica (yield)

Quando precisa de lógica maior:

String result = switch (status) {
    case 1 -> {
        System.out.println("Processando ativo");
        yield "ATIVO";
    }
    case 2 -> {
        yield "INATIVO";
    }
    default -> "DESCONHECIDO";
};

👉 yield substitui o antigo return dentro do switch

4. Switch com Pattern Matching

Aqui começa o nível profissional.

static String process(Object obj) {
    return switch (obj) {
        case String s -> "Texto: " + s;
        case Integer i -> "Número: " + i;
        case User u -> "Usuário: " + u.getName();
        default -> "Desconhecido";
    };
}

👉 sem cast 👉 sem instanceof separado 👉 muito mais legível

Guards dentro do switch

Agora junta tudo:

static String checkUser(Object obj) {
    return switch (obj) {
        case User u && u.getAge() < 18 -> "Menor de idade";
        case User u && u.getAge() >= 18 -> "Adulto";
        default -> "Outro tipo";
    };
}

👉 substitui vários if/else 👉 deixa regra clara

Switch com Records

record User(String name, int age) {}

static String process(Object obj) {
    return switch (obj) {
        case User(String name, int age) -> name + " tem " + age + " anos";
        default -> "Outro";
    };
}

👉 destruturação automática 👉 código elegante

Exemplo real (código de produção)

public String handlePayment(Object payment) {
    return switch (payment) {
        case Pix pix -> "Pagamento via PIX";
        case Card card && card.isCredit() -> "Cartão de crédito";
        case Card card -> "Cartão de débito";
        case Boleto boleto -> "Boleto";
        default -> "Método desconhecido";
    };
}

👉 isso aqui substitui uma árvore gigante de if/else

Exaustividade (segurança de compilação)

Se você usa enum:

enum Status {
    ACTIVE, INACTIVE
}

String result = switch (status) {
    case ACTIVE -> "Ativo";
    case INACTIVE -> "Inativo";
};

👉 se esquecer um case → erro de compilação

🔥 isso evita bug em produção

Erros comuns

usar switch moderno como se fosse antigo
criar blocos gigantes
ignorar default
misturar lógica demais

Quando usar

Use quando:

múltiplos cenários simples
processamento por tipo
regras claras e separadas

Evite quando:

lógica muito complexa
depende de vários estados externos

Dica de senior

Switch moderno não é só sintaxe.

👉 é clareza de intenção

Se o código não ficou mais legível… você usou errado.

Antes vs Depois

Antes	Agora
switch tradicional	switch expression
break	->
variável mutável	expressão direta
instanceof separado	pattern matching

Conclusão

Switch moderno no Java 26 é:

✔ mais limpo
✔ mais seguro
✔ mais expressivo

E principalmente:

👉 reduz MUITO código desnecessário

Java 26: Switch Moderno na Prática (expressões, pattern matching e muito mais)