Comando switch em Java: casos, fall-through e sintaxe de seta

Para que serve o switch

Um switch compara um valor com uma lista de opções fixas e executa o ramo que corresponde. Quando você se pega escrevendo uma longa cadeia if/else if que continua testando a mesma variável contra diferentes constantes, um switch diz a mesma coisa com mais clareza.

Ele só faz verificações de igualdade contra constantes de tempo de compilação: não pode testar intervalos nem combinar condições. Para isso, fique com if/else.

O comando switch clássico

A forma tradicional usa rótulos case com dois-pontos e um break depois de cada ramo:

public class Main {
    public static void main(String[] args) {
        int day = 3;

        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            default:
                System.out.println("Some other day");
        }
    }
}

O Java avalia day, salta para o case correspondente, executa suas instruções, e o break sai do switch. O ramo default é executado quando nada mais corresponde: pense nele como o else. Ele é opcional, mas incluí-lo é uma boa prática para que valores inesperados não passem despercebidos em silêncio.

A armadilha do break: o fall-through

Este é o erro de switch mais comum de todos. Se você omite um break, a execução não para no fim de um case correspondente: ela cai no case seguinte e continua executando até encontrar um break ou a chave de fechamento:

public class Main {
    public static void main(String[] args) {
        int level = 1;

        switch (level) {
            case 1:
                System.out.println("Level 1");
                // no break - falls through!
            case 2:
                System.out.println("Level 2");
            case 3:
                System.out.println("Level 3");
                break;
        }
    }
}

Você poderia esperar apenas Level 1, mas isto imprime as três linhas. Como o case 1 não tem break, o controle desliza direto para case 2 e case 3. Sempre adicione break, a menos que você realmente queira o fall-through, e quando depender dele, deixe um comentário para que o próximo leitor saiba que foi intencional.

Agrupando casos

O fall-through tem um uso legítimo e organizado: empilhar rótulos case para que vários valores compartilhem um mesmo bloco. Coloque os rótulos um após o outro, sem código entre eles:

public class Main {
    public static void main(String[] args) {
        char grade = 'B';

        switch (grade) {
            case 'A':
            case 'B':
            case 'C':
                System.out.println("Pass");
                break;
            case 'D':
            case 'F':
                System.out.println("Fail");
                break;
            default:
                System.out.println("Unknown grade");
        }
    }
}

Aqui 'A', 'B' e 'C' executam todos a mesma linha "Pass". Esta é a forma prevista de dizer "qualquer um destes valores faz a mesma coisa".

switch com Strings

Você não está limitado a números. Desde o Java 7 você pode usar switch com um String, o que é perfeito para escolhas de menu ou nomes de comandos:

public class Main {
    public static void main(String[] args) {
        String command = "stop";

        switch (command) {
            case "start":
                System.out.println("Starting...");
                break;
            case "stop":
                System.out.println("Stopping...");
                break;
            default:
                System.out.println("Unknown command: " + command);
        }
    }
}

A comparação diferencia maiúsculas de minúsculas: "Stop" não corresponderia a "stop", então normalize primeiro (por exemplo, command.toLowerCase()) se a capitalização da entrada variar. Mais uma pegadinha: se command for null, o switch lança uma NullPointerException, então proteja-se contra null antes de chegar nele.

A moderna sintaxe de seta

O Java mais recente (14+) acrescenta uma forma com seta, case label -> ..., que corrige por design a armadilha do fall-through. Cada case de seta executa exatamente um ramo e nunca cai, então não há nenhum break para esquecer:

public class Main {
    public static void main(String[] args) {
        int day = 6;

        switch (day) {
            case 1, 2, 3, 4, 5 -> System.out.println("Weekday");
            case 6, 7          -> System.out.println("Weekend");
            default            -> System.out.println("Invalid day");
        }
    }
}

Repare que você agrupa valores com uma vírgula (case 6, 7) em vez de empilhar rótulos, e não há um único break à vista. Para múltiplas instruções, use um bloco: case 1 -> { ...; ... }. Prefira esta forma em código novo: ela é mais curta e elimina toda uma classe de erros.

switch como expressão

A forma com seta também pode produzir um valor. Uma expressão switch retorna um resultado que você pode atribuir diretamente a uma variável: sem variável temporária, sem atribuição repetida em cada ramo:

public class Main {
    public static void main(String[] args) {
        int month = 4;

        int days = switch (month) {
            case 1, 3, 5, 7, 8, 10, 12 -> 31;
            case 4, 6, 9, 11           -> 30;
            case 2                     -> 28;
            default -> throw new IllegalArgumentException("Bad month: " + month);
        };

        System.out.println("Days: " + days);
    }
}

Todo o switch (...) { ... } é avaliado para um número armazenado em days. Note o ponto e vírgula depois da chave de fechamento: ele faz parte da instrução de atribuição. Uma expressão switch precisa ser exaustiva (cobrir todos os valores possíveis), e é por isso que o default está aqui. Se um ramo precisa de várias instruções antes de retornar um valor, use um bloco com yield:

case 2 -> {
    boolean leap = (year % 4 == 0);
    yield leap ? 29 : 28;
}

O yield é a forma como um bloco de seta devolve seu valor, o equivalente, no mundo das expressões, ao break que carrega um resultado.

Próximo: laços for

O switch escolhe um ramo entre muitos; às vezes, em vez disso, você precisa repetir um bloco muitas vezes. O laço for executa código um número controlado de vezes (percorrendo um intervalo ou passando por cada item) e é a próxima página.