Switch clássico: sintaxe e exemplos

1. Introdução

Imagine o seguinte: você está escrevendo um programa para uma cafeteria. O usuário pode escolher uma bebida, e você precisa reagir a essa escolha. É claro que você pode usar um monte de if-else if-else, mas não fica muito bonito:

if (choice == 1) 
{
    System.out.println("Você escolheu espresso.");
} 
else if (choice == 2) 
{
    System.out.println("Você escolheu cappuccino.");
} 
else if (choice == 3) 
{
    System.out.println("Você escolheu latte.");
} 
else 
{
    System.out.println("Essa bebida não existe.");
}

Convenhamos, fica pesado. E se houver 10 ou 20 opções? É aí que entra o operador switch, que permite implementar de forma elegante e compacta a escolha entre muitas opções pelo valor de uma variável.

Sintaxe do switch clássico

A sintaxe do switch em Java é assim:

switch (expressão) 
{
    case valor1:
        // ações, se expressão == valor1
        break;
    case valor2:
        // ações, se expressão == valor2
        break;
    ...
    default:
        // ações, se não casar com nenhum case
        break;
}

Elementos principais:

• switch (expressão) — a expressão cujo resultado é comparado com cada case.
• case valor: — a alternativa com a qual a expressão é comparada.
• break; — encerra a execução do bloco switch (caso contrário — ocorre “queda” para o próximo case).
• default: — executa se não casar com nenhum case.

2. Exemplos de uso do switch

Exemplo 1: O clássico — escolhendo a bebida

Vamos implementar um menu para a cafeteria:

import java.util.Scanner;

public class CoffeeShop 
{
    public static void main(String[] args) 
    {
        Scanner console = new Scanner(System.in);

        System.out.println("Escolha a bebida:");
        System.out.println("1 - Espresso");
        System.out.println("2 - Cappuccino");
        System.out.println("3 - Latte");
        int choice = console.nextInt();

        switch (choice) 
        {
            case 1:
                System.out.println("Você escolheu espresso.");
                break;
            case 2:
                System.out.println("Você escolheu cappuccino.");
                break;
            case 3:
                System.out.println("Você escolheu latte.");
                break;
            default:
                System.out.println("Essa bebida não existe.");
                break;
        }
    }
}

O que acontece:

• O usuário digita o número da bebida.
• O valor da variável choice é comparado com cada case.
• Se casar — o bloco correspondente é executado; em seguida, break encerra a execução do switch.
• Se não casar com nenhum — executa o default.

Exemplo 2: Switch com strings

Não há muitos tipos que você pode usar dentro do switch, mas strings — pode! Isso é prático para menus de comandos:

import java.util.Scanner;

public class CommandMenu 
{
    public static void main(String[] args) 
    {
        Scanner console = new Scanner(System.in);

        System.out.println("Digite um comando (start, stop, pause):");
        String command = console.nextLine();

        switch (command) 
        {
            case "start":
                System.out.println("Iniciando o programa!");
                break;
            case "stop":
                System.out.println("Parando o programa.");
                break;
            case "pause":
                System.out.println("Pausa.");
                break;
            default:
                System.out.println("Comando desconhecido.");
                break;
        }
    }
}

Atenção: a comparação de strings no switch diferencia maiúsculas de minúsculas! "Start" e "start" são strings diferentes.

3. Quais tipos o switch clássico suporta?

No switch clássico, você pode usar apenas certos tipos:

• Tipos primitivos inteiros: byte, short, char, int
• Enums: enum (falaremos sobre eles na próxima aula)
• Strings: String — a comparação diferencia maiúsculas de minúsculas

Não é possível usar: boolean, float, double, arrays, objetos arbitrários de classes (exceto enum e String).

Exemplo com char

char grade = 'B';

switch (grade) 
{
    case 'A':
        System.out.println("Excelente!");
        break;
    case 'B':
        System.out.println("Bom.");
        break;
    case 'C':
        System.out.println("Satisfatório.");
        break;
    default:
        System.out.println("Tente novamente.");
        break;
}

4. Obrigatoriedade de break: o que acontece se esquecer?

O erro mais comum dos iniciantes — esquecer o break;. Vamos ver o que acontece:

int day = 2;

switch (day) 
{
    case 1:
        System.out.println("Segunda-feira");
        break;
    case 2:
        System.out.println("Terça-feira");
    case 3:
        System.out.println("Quarta-feira");
        break;
    default:
        System.out.println("Dia desconhecido");
        break;
}

Resultado:

Terça-feira
Quarta-feira

Por quê? Porque após case 2 não há break, e a execução “cai” no próximo case (isso se chama fall-through). Às vezes isso é útil, mas na maioria das vezes é um erro.

5. Agrupando case: quando várias opções têm o mesmo comportamento

Se para vários valores o comportamento for o mesmo, você pode escrevê-los em sequência:

int month = 1;

switch (month) 
{
    case 12:
    case 1:
    case 2:
        System.out.println("Inverno");
        break;
    case 3:
    case 4:
    case 5:
        System.out.println("Primavera");
        break;
    case 6:
    case 7:
    case 8:
        System.out.println("Verão");
        break;
    case 9:
    case 10:
    case 11:
        System.out.println("Outono");
        break;
    default:
        System.out.println("Mês desconhecido");
        break;
}

Aqui: se month — 12, 1 ou 2, o programa imprimirá "Inverno".

6. Comparação: switch vs. if-else

7. Erros comuns ao trabalhar com switch

Erro nº 1: esqueceu o break
A causa mais comum de bugs: esqueceu o break — e o código executa um case que você não esperava.

Erro nº 2: tipo não suportado
Tentar usar double, float ou boolean — o compilador dirá “não pode”.

Erro nº 3: strings com maiúsculas/minúsculas diferentes
O usuário digitou "Start", mas você espera "start" — o switch não vai casar. Melhor normalizar as strings para um único caso antes:

switch (command.toLowerCase()) 
{
    case "start":
        // ...
}

Erro nº 4: variável em case, e não constante
Apenas constantes são permitidas em case. Se usar uma variável — ocorrerá erro de compilação.

Erro nº 5: case duplicados
Dois valores de case iguais — o compilador não perdoa.