Aula 45 - switch-case-break

A Estrutura switch-case-break

A estrutura switch-case é uma alternativa para múltiplos if-else if quando queremos comparar o valor de uma variável com diversas constantes. Esta estrutura torna o código mais legível quando há muitas condições baseadas no mesmo valor.

switch (expressão)

↓

case valor1:
código para valor1
break;

case valor2:
código para valor2
break;

default:
código padrão
break;

Anatomia do switch-case-break:

switch (expressão) { // expressão deve ser um número inteiro, String, ou enum
  case valor1: // valor específico a ser comparado com a expressão
    (...); // código a ser executado se expressão == valor1
    break; // interrompe a execução do switch
  case valor2: // pode ter múltiplos cases
    (...); // código para valor2
    break;
  case valor3: // cases sem break "caem" para o próximo case
  case valor4: // útil quando mesmo código serve para diferentes valores
    (...); // código compartilhado para valor3 e valor4
    break;
  default: // opcional - executado se nenhum case corresponder
    (...); // código padrão
    break; // break no default é opcional mas recomendado
}

Tipos de Dados Compatíveis com switch

Em Java, a expressão no switch pode ser dos seguintes tipos:

Tipos primitivos: byte, short, char e int
Classes Wrapper: Byte, Short, Character e Integer
Enum (tipos de enumeração)
String (a partir do Java 7)

Observação: Tipos de ponto flutuante (float e double), booleanos (boolean) e tipos longos (long) não podem ser usados em expressões switch.

Exemplo Básico: Dias da Semana

public class DiaDaSemana {
    public static void main(String[] args) {
        // Código do dia da semana (1-7)
        int diaSemana = 3;
        
        // Utilizando switch-case para mostrar o nome do dia
        System.out.print("O dia " + diaSemana + " corresponde a: ");
        
        switch (diaSemana) {
            case 1:
                System.out.println("Domingo");
                break;
            case 2:
                System.out.println("Segunda-feira");
                break;
            case 3:
                System.out.println("Terça-feira");
                break;
            case 4:
                System.out.println("Quarta-feira");
                break;
            case 5:
                System.out.println("Quinta-feira");
                break;
            case 6:
                System.out.println("Sexta-feira");
                break;
            case 7:
                System.out.println("Sábado");
                break;
            default:
                System.out.println("Dia inválido!");
                break;
        }
    }
}

O dia 3 corresponde a: Terça-feira

Comparação com if-else if: O código acima é equivalente ao seguinte código usando if-else if:

if (diaSemana == 1) {
    System.out.println("Domingo");
} else if (diaSemana == 2) {
    System.out.println("Segunda-feira");
} else if (diaSemana == 3) {
    System.out.println("Terça-feira");
} else if (diaSemana == 4) {
    System.out.println("Quarta-feira");
} else if (diaSemana == 5) {
    System.out.println("Quinta-feira");
} else if (diaSemana == 6) {
    System.out.println("Sexta-feira");
} else if (diaSemana == 7) {
    System.out.println("Sábado");
} else {
    System.out.println("Dia inválido!");
}

Para este tipo de verificação múltipla de um único valor, a estrutura switch-case é mais limpa e legível.

Comportamento de Fall-through (Sem break)

Se você omitir a instrução break em um case, a execução "cairá" (fall-through) para o próximo case, continuando a execução. Isso pode ser útil em alguns casos, mas também pode causar comportamentos inesperados se não for intencional.

public class SwitchSemBreak {
    public static void main(String[] args) {
        char vogal = 'e';
        
        System.out.print("Vogal '" + vogal + "' é ");
        
        switch (vogal) {
            case 'a':
                System.out.println("a primeira vogal do alfabeto.");
                break;
            case 'e':
                System.out.println("a segunda vogal do alfabeto.");
                // Sem break - cairá para o próximo case
            case 'i':
                System.out.println("uma vogal do meio do alfabeto.");
                break;
            case 'o':
            case 'u':
                // Mesmo comportamento para 'o' e 'u'
                System.out.println("uma vogal do final do alfabeto.");
                break;
            default:
                System.out.println("não é uma vogal.");
                break;
        }
    }
}

Vogal 'e' é a segunda vogal do alfabeto.

uma vogal do meio do alfabeto.

Atenção: Neste exemplo, como não há break após o case 'e', o código continua executando o case 'i'. Este comportamento pode ser útil quando desejamos o mesmo comportamento para múltiplos cases, mas pode causar bugs se não for intencional.

Uso Intencional de Fall-through

O comportamento de fall-through pode ser usado intencionalmente quando queremos o mesmo comportamento para múltiplos valores:

public class DiasUteis {
    public static void main(String[] args) {
        int diaSemana = 3;
        
        switch (diaSemana) {
            case 1:
            case 7:
                // Código para domingo (1) ou sábado (7)
                System.out.println("Fim de semana!");
                break;
            case 2:
            case 3:
            case 4:
            case 5:
            case 6:
                // Código para dias úteis (2-6)
                System.out.println("Dia útil!");
                break;
            default:
                System.out.println("Dia inválido!");
                break;
        }
        
        // Outro exemplo: nota em conceito
        int nota = 8;
        
        System.out.print("Nota " + nota + ": ");
        
        switch (nota) {
            case 10:
                System.out.print("Excelente! ");
                // Fall-through intencional
            case 9:
            case 8:
                System.out.print("Muito bom! ");
                // Fall-through intencional
            case 7:
                System.out.println("Aprovado.");
                break;
            case 6:
            case 5:
                System.out.println("Em recuperação.");
                break;
            default:
                System.out.println("Reprovado.");
                break;
        }
    }
}

Dia útil! Nota 8: Muito bom! Aprovado.

Dica: Quando usar fall-through intencionalmente, é uma boa prática adicionar um comentário // fall-through para indicar que a omissão do break é intencional.

Switch com String (Java 7+)

A partir do Java 7, é possível usar Strings em expressões switch:

public class SwitchComString {
    public static void main(String[] args) {
        String diaSemana = "terça";
        
        // Convertendo para minúsculas para tornar a comparação case-insensitive
        switch (diaSemana.toLowerCase()) {
            case "domingo":
                System.out.println("Fim de semana, dia 1");
                break;
            case "segunda":
                System.out.println("Dia útil, dia 2");
                break;
            case "terça":
                System.out.println("Dia útil, dia 3");
                break;
            case "quarta":
                System.out.println("Dia útil, dia 4");
                break;
            case "quinta":
                System.out.println("Dia útil, dia 5");
                break;
            case "sexta":
                System.out.println("Dia útil, dia 6");
                break;
            case "sábado":
                System.out.println("Fim de semana, dia 7");
                break;
            default:
                System.out.println("Dia inválido!");
                break;
        }
        
        // Outro exemplo: processando comandos
        String comando = "SAIR";
        
        switch (comando.toUpperCase()) {
            case "INICIAR":
                System.out.println("Iniciando o sistema...");
                break;
            case "PAUSAR":
                System.out.println("Sistema pausado.");
                break;
            case "CONTINUAR":
                System.out.println("Continuando operação...");
                break;
            case "SAIR":
                System.out.println("Encerrando o sistema...");
                break;
            default:
                System.out.println("Comando desconhecido!");
                break;
        }
    }
}

Dia útil, dia 3

Encerrando o sistema...

Observação: Ao usar Strings em switch, tenha cuidado com maiúsculas e minúsculas. Se a distinção entre maiúsculas e minúsculas não for importante, é uma boa prática converter a String para minúsculas ou maiúsculas antes de usar o switch.

Switch com Enum

Enums (tipos enumerados) são ideais para uso com switch e tornam o código mais legível e seguro:

public class SwitchComEnum {
    // Definindo um enum para dias da semana
    public enum DiaSemana {
        DOMINGO, SEGUNDA, TERCA, QUARTA, QUINTA, SEXTA, SABADO
    }
    
    public static void main(String[] args) {
        // Utilizando enum
        DiaSemana dia = DiaSemana.TERCA;
        
        switch (dia) {
            case DOMINGO:
                System.out.println("Fim de semana, dia 1");
                break;
            case SEGUNDA:
                System.out.println("Dia útil, dia 2");
                break;
            case TERCA:
                System.out.println("Dia útil, dia 3");
                break;
            case QUARTA:
                System.out.println("Dia útil, dia 4");
                break;
            case QUINTA:
                System.out.println("Dia útil, dia 5");
                break;
            case SEXTA:
                System.out.println("Dia útil, dia 6");
                break;
            case SABADO:
                System.out.println("Fim de semana, dia 7");
                break;
        }
        
        // Enum para status de pedido
        enum StatusPedido {
            RECEBIDO, PREPARANDO, PRONTO, ENTREGUE, CANCELADO
        }
        
        StatusPedido status = StatusPedido.PREPARANDO;
        
        switch (status) {
            case RECEBIDO:
                System.out.println("Pedido recebido, aguardando processamento.");
                break;
            case PREPARANDO:
                System.out.println("Pedido em preparação.");
                break;
            case PRONTO:
                System.out.println("Pedido pronto para entrega.");
                break;
            case ENTREGUE:
                System.out.println("Pedido entregue com sucesso.");
                break;
            case CANCELADO:
                System.out.println("Pedido cancelado.");
                break;
        }
    }
}

Dia útil, dia 3

Pedido em preparação.

Vantagens de usar enum com switch:

O compilador verifica se todos os valores possíveis do enum estão cobertos
Evita erros de digitação em Strings ou uso de valores numéricos ambíguos
Torna o código mais legível e autodocumentado
Não precisa de um case default se todos os valores do enum estiverem cobertos

Switch Aninhado

É possível ter um switch dentro de outro switch, criando uma estrutura aninhada:

public class SwitchAninhado {
    public static void main(String[] args) {
        int departamento = 2; // 1: Vendas, 2: Suporte, 3: Financeiro
        int nivel = 1;       // 1: Básico, 2: Intermediário, 3: Avançado
        
        switch (departamento) {
            case 1:
                System.out.println("Departamento de Vendas");
                switch (nivel) {
                    case 1:
                        System.out.println("Vendedor Júnior");
                        break;
                    case 2:
                        System.out.println("Vendedor Pleno");
                        break;
                    case 3:
                        System.out.println("Vendedor Sênior");
                        break;
                    default:
                        System.out.println("Nível de vendas desconhecido");
                        break;
                }
                break;
            case 2:
                System.out.println("Departamento de Suporte");
                switch (nivel) {
                    case 1:
                        System.out.println("Suporte Básico");
                        break;
                    case 2:
                        System.out.println("Suporte Técnico");
                        break;
                    case 3:
                        System.out.println("Suporte Especializado");
                        break;
                    default:
                        System.out.println("Nível de suporte desconhecido");
                        break;
                }
                break;
            case 3:
                System.out.println("Departamento Financeiro");
                switch (nivel) {
                    case 1:
                        System.out.println("Assistente Financeiro");
                        break;
                    case 2:
                        System.out.println("Analista Financeiro");
                        break;
                    case 3:
                        System.out.println("Gerente Financeiro");
                        break;
                    default:
                        System.out.println("Nível financeiro desconhecido");
                        break;
                }
                break;
            default:
                System.out.println("Departamento desconhecido");
                break;
        }
    }
}

Departamento de Suporte

Suporte Básico

Cuidado: Switch aninhado pode tornar o código complexo e difícil de manter. Em muitos casos, pode ser melhor usar métodos separados ou outras abordagens para evitar a complexidade excessiva.

Boas Práticas com switch-case

Sempre use break: A menos que o fall-through seja intencional, sempre inclua o break no final de cada case.
Documente o fall-through intencional: Se você omitir o break intencionalmente, adicione um comentário para indicar que é intencional.
Considere usar enum: Quando aplicável, use enum em vez de números ou strings para tornar o código mais legível e seguro.
Evite switchs aninhados complexos: Se um switch aninhado estiver ficando muito complexo, considere refatorar para métodos separados.
Mantenha o default: Mesmo quando acha que cobriu todos os casos possíveis, é uma boa prática incluir um case default para lidar com valores inesperados.

Quando Usar switch vs. if-else if

Use switch quando:	Use if-else if quando:
Comparando uma única variável com múltiplos valores constantes	Testando múltiplas condições diferentes
Os valores de comparação são constantes conhecidas	Usando expressões complexas ou intervalos de valores
Há muitos casos a serem verificados (4 ou mais)	Há poucas condições a serem verificadas
Trabalhando com enums ou conjuntos limitados de strings	Trabalhando com tipos não suportados pelo switch (boolean, double, etc.)