Instruções `switch` em

Sobre Instruções `switch`

Assim como uma condicional if/else, uma instrução switch permite mudar o fluxo do programa executando código de forma condicional. A diferença é que uma instrução switch só consegue comparar o valor de uma expressão primitiva ou de uma string com valores constantes predefinidos.

Algumas palavras-chave são úteis ao usar uma instrução switch.

• switch: essa palavra-chave permite declarar a estrutura do switch. Ela vem seguida da expressão ou da variável que vai fazer o resultado mudar.
• case: você vai usar essa para declarar as diferentes possibilidades para o resultado.
• break: a palavra-chave break é muito útil para interromper a execução do switch no fim do fluxo desejado. Se você esquecer dela, o programa continua e pode levar a resultados inesperados.
• default: como o nome diz, use-a como resultado padrão quando nenhum outro case corresponder ao resultado da sua expressão.

Na forma mais simples, elas testam uma expressão primitiva ou de string e tomam uma decisão com base no valor dela. Por exemplo:

String direction = getDirection();
switch (direction) {
    case "left":
        goLeft();
        break;
    case "right":
        goRight();
        break;
    default:
        // otherwise
        markTime();
        break;
}

A partir do Java 14 (disponível como prévia antes, no Java 12 e no Java 13), é possível usar a implementação "aprimorada" do switch.

1. Você tem a possibilidade de atribuir vários valores a um único case. Na instrução switch tradicional, você pode usar o fall-through. No exemplo a seguir, case 1 e case 3 vão executar a mesma coisa. Isso acontece porque case 1 não usa a palavra-chave break.

   switch (number) {
       case 1:
       case 3:
           // do same stuff
           break;
       case 2:
           // do different stuff
           break;
       // (...)
   }
   

   Na switch expression aprimorada, você pode atribuir vários valores a um case diretamente. Veja o exemplo a seguir:

   switch (number) {
       case 1, 3:
           // do stuff
           break;
       case 2:
           // do other stuff
           break;
       // (...)
   }
   

2. Agora você pode escrever um switch-statement ou uma switch expression. Qual é a diferença? Basicamente, uma instrução espera uma lógica estrita, enquanto uma expressão pode retornar um valor. Em vez de:

   String result = "";
   switch (expression) {
       case "bob":
           result = "bob";
           break;
       // (...)
   }
   

   Você pode fazer:

   String result = switch (expression) {
       case "bob":
           yield "bob";
       // (...)
   }
   

   O yield funciona como um return, só que é para uma switch expression. Como o yield encerra a expressão, o break não é necessário aqui.

3. Outra diferença entre instruções switch e expressões switch: nas expressões switch você PRECISA cobrir todos os casos. Seja tendo um case para todos os valores possíveis, seja usando um caso default.

4. Você pode usar -> em vez de :. O -> permite que você não inclua a palavra-chave break. As duas notações podem ser usadas, mas, em um switch, você precisa escolher apenas uma.

    switch(expression) {
        case 1 -> yield "one"
        case 2 -> yield "two"
        default: yield "other number" // Removing this will result in a compile error
    }
   

5. O escopo. O switch tradicional pode levar a comportamentos inesperados por causa do seu escopo, já que existe apenas um escopo para todo o switch.

    switch(expression) {
        case 1:
            String message = "something";
            break;
        case 2:
            String message = "anything";
            break;
        // (...)
    }
   

   Esse exemplo não funciona porque message é declarada duas vezes no switch. Dá para resolver assim:

    switch (expression) {
        case 1: {
            String message = "something";
            break;
        }
        case 2: {
            String message = "anything";
            break;
        }
        // (...)
    }
   

   Como o {} delimita o escopo do case. No entanto, isso não é intuitivo, porque o {} não é obrigatório. Mas, se você usar a nova notação ->, ela precisa ser seguida por uma destas opções: uma única instrução/expressão, uma instrução throw ou um bloco {}. Chega de confusão!

Você pode encontrar mais informações sobre o switch aprimorado neste artigo e neste outro, além da documentação oficial da Oracle.

Além disso, um recurso chamado Guarded Patterns foi adicionado no Java 21 e permite fazer verificações no próprio rótulo do case.

String dayOfMonth = getDayOfMonth();
String day = "";
return switch (day) {
    case "Tuesday" when dayOfMonth == 13 -> "Forbidden day!!";
    case "Monday", "Tuesday", "Wednesday", "Thursday", "Friday" -> "Week day";
    case "Saturday", "Sunday" -> "Weekend";
    default -> "Unknown";
};

Você pode encontrar mais informações sobre a switch expression no Java 21 neste blog