# A evolução do switch no Java: do statement ao pattern matching

---

A evolução do **switch** no **Java** ilustra como a linguagem vem se adaptando para escrever código mais conciso, seguro e expressivo. Inicialmente concebido como um simples mecanismo de controle de fluxo, o **switch** passou por diversas transformações – do tradicional **switch statement** ao moderno **switch expression** com **pattern matching** – ampliando significativamente suas capacidades e flexibilidade.

## 1\. Switch Statement Clássico

Nas versões iniciais do **Java**, o **switch** era utilizado para testar uma variável contra um conjunto fixo de valores constantes. Ele aceitava tipos primitivos (como `int`, `char`), `enum` e, posteriormente, `String`.

Embora funcional, exigia muito código repetitivo e atenção com o uso do break, que evitava o fall through – quando a execução continua no próximo case mesmo após encontrar um correspondente.

```java
String nivel = "intermediário";
switch (nivel) {
    case "iniciante":
        System.out.println("Você está começando.");
        break;
    case "intermediário":
        System.out.println("Você já tem alguma experiência.");
        break;
    case "avançado":
        System.out.println("Você domina a linguagem!");
        break;
    default:
        System.out.println("Nível desconhecido.");
}
```

Problemas comuns:

* Esquecer do break, gerando bugs difíceis de rastrear.
    
* Sintaxe extensa e repetitiva.
    
* Falta de suporte a retorno direto de valores.
    

## 2\. Switch Expression (Java 12+ / Java 14)

A partir do **Java 12**, e estabilizado no **Java 14** com a **JEP 361**, foi introduzido o conceito de switch expressions. Com ele, o switch deixa de ser apenas um comando e passa a ser também uma expressão que retorna valores.

Vantagens:

* Sintaxe concisa: -> elimina o break e evita fall through.
    
* Retorno de valores: pode-se armazenar diretamente o resultado do switch.
    

```java
int mes = 2;
String nomeMes = switch (mes) {
    case 1 -> "Janeiro";
    case 2 -> "Fevereiro";
    case 3 -> "Março";
    default -> "Mês inválido";
};
System.out.println("O mês é: " + nomeMes);
```

Também é possível usar blocos para lógica mais complexa:

```java
int numero = 5;
String resultado = switch (numero) {
    case 1, 2, 3 -> "Baixo";
    case 4, 5, 6 -> {
        System.out.println("Faixa intermediária");
        yield "Médio";
    }
    default -> "Alto";
};
```

## 3\. Pattern Matching para Switch (Java 17+ / Java 21)

A terceira etapa da evolução é ainda mais poderosa: o pattern matching para switch, introduzido em preview no **Java 17** e estabilizado no **Java 21** com a **JEP 441**. Essa funcionalidade transforma o switch em uma ferramenta capaz de verificar padrões de tipo, extrair variáveis, e aplicar condições diretamente nos cases.

Novos recursos com pattern matching:

* Testar tipos dinamicamente: sem necessidade de instanceof + cast.
    
* Extração de variáveis inline: o valor é automaticamente atribuído ao tipo correto.
    
* Guards (when): permitem adicionar condições extras.
    
* Tratamento de null diretamente.
    
* Desconstrução de records.
    

Exemplo prático:

```java
Object valor = 42;
String resultado = switch (valor) {
    case Integer num && num > 50 -> "Número grande";
    case Integer num -> "Número pequeno ou médio";
    case String s when s.length() > 3 -> "Texto longo";
    case String s -> "Texto curto";
    case null -> "Valor nulo";
    default -> "Outro tipo";
};
System.out.println("Resultado: " + resultado);
```

Com record:

```java
record Pessoa(String nome, int idade) {}

Object obj = new Pessoa("Ana", 30);

String descricao = switch (obj) {
    case Pessoa(String nome, int idade) when idade >= 18 -> nome + " é maior de idade.";
    case Pessoa(String nome, int idade) -> nome + " é menor de idade.";
    default -> "Tipo desconhecido.";
};
```

### Comparação de Sintaxe:

| Recurso | Disponível a partir de | Sintaxe mais enxuta | Retorna valor | Testa tipo com guard |
| --- | --- | --- | --- | --- |
| Switch Statement Clássico | Java 1 | ❌ | ❌ | ❌ |
| Switch Expression | Java 12/14 | ✅ | ✅ | ❌ |
| Pattern Matching | Java 17/21 | ✅ | ✅ | ✅ |

### Quando usar cada um?

| Situação | Recomendação |
| --- | --- |
| Precisa apenas executar comandos simples? | switch statement pode ser suficiente. |
| Deseja retornar um valor com clareza e segurança? | Prefira switch expression. |
| Precisa testar tipos de objetos, aplicar condições e extrair dados? | Use switch com pattern matching. |

A transformação do switch no Java reflete o compromisso da linguagem com a evolução sem perder compatibilidade. De uma estrutura limitada e propensa a erros, o switch se tornou uma ferramenta moderna, expressiva e versátil.