Palavra-chave case em java

A palavra-chave case em Java é usada dentro de uma estrutura de controle switch para especificar um bloco de código que será executado quando o valor da expressão do switch corresponder ao valor de case. Cada case representa um possível valor da expressão do switch, e o bloco de código associado a um case será executado se houver uma correspondência.

Estrutura do switch com case

Aqui está a estrutura básica de um switch em Java:

switch (expressao) {
    case valor1:
        // Código a ser executado se expressao == valor1
        break;
    case valor2:
        // Código a ser executado se expressao == valor2
        break;
    default:
        // Código a ser executado se nenhum dos casos corresponder
}

Explicação

• switch (expressao): A expressão é avaliada e comparada com os valores definidos nos casos.
• case valor1:: Se a expressão for igual a valor1, o bloco de código associado a esse case será executado.
• break;: A palavra-chave break é usada para sair do switch após a execução do bloco de código correspondente. Se o break for omitido, a execução continuará nos casos seguintes até encontrar um break ou até o final do switch.
• default:: O bloco default é opcional e será executado se nenhum dos casos corresponder à expressão.

Exemplo de Uso

Aqui está um exemplo simples de como usar case em um switch:

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

        switch (diaDaSemana) {
            case 1:
                System.out.println("Segunda-feira");
                break;
            case 2:
                System.out.println("Terça-feira");
                break;
            case 3:
                System.out.println("Quarta-feira");
                break;
            case 4:
                System.out.println("Quinta-feira");
                break;
            case 5:
                System.out.println("Sexta-feira");
                break;
            case 6:
                System.out.println("Sábado");
                break;
            case 7:
                System.out.println("Domingo");
                break;
            default:
                System.out.println("Dia inválido");
                break;
        }
    }
}

Saída:

Quarta-feira

Neste exemplo, a variável diaDaSemana é comparada com cada valor de case. Quando a expressão é igual a 3, o bloco de código associado ao case 3 é executado e “Quarta-feira” é impresso.

Pontos Importantes

1. Tipagem: A expressão do switch deve ser de um tipo que pode ser comparado com os valores de case. Em Java, isso inclui tipos primitivos (byte, short, int, char), enum e String (a partir do Java 7).
2. Escopo do case: Os blocos de código dos casos devem ser separados por break para evitar a execução “cascata” (fall-through) para os casos seguintes, a menos que você queira especificamente esse comportamento.
3. default: Embora opcional, o bloco default é útil para tratar casos em que a expressão não corresponde a nenhum dos valores definidos.

Exemplo de Fall-Through

Se você deseja que vários casos executem o mesmo bloco de código, você pode omitir o break:

public class ExemploFallThrough {
    public static void main(String[] args) {
        int numero = 2;

        switch (numero) {
            case 1:
            case 2:
            case 3:
                System.out.println("Número pequeno");
                break;
            case 4:
            case 5:
                System.out.println("Número médio");
                break;
            default:
                System.out.println("Número grande");
                break;
        }
    }
}

Saída:

Número pequeno

Aqui, tanto case 1, case 2 e case 3 imprimem “Número pequeno” porque não há break entre eles, resultando em uma execução contínua para todos os casos que correspondam.

Conclusão

A palavra-chave case em Java é fundamental para o controle de fluxo com a estrutura switch, permitindo a execução condicional de blocos de código com base no valor de uma expressão. Utilizar case corretamente ajuda a escrever código mais legível e eficiente para condições baseadas em valores discretos.