palabra clave case en Java

La palabra clave case en Java se utiliza dentro de una sentencia switch para definir un bloque de código que se ejecuta cuando la expresión del conmutador coincide con un valor específico. Cada etiqueta case debe ser única dentro de la sentencia switch y va seguida de dos puntos.

Utilización

La palabra clave case se utiliza para manejar múltiples condiciones de una manera más legible y eficiente que múltiples sentencias if-else. Es especialmente útil cuando necesitas ejecutar código diferente en función del valor de una variable.

Syntax

switch (expression) {
    case value1:
        // code block
        break;
    case value2:
        // code block
        break;
    // more cases...
    default:
        // default code block
}

• expression: La variable o expresión evaluada una vez al principio de la sentencia switch.
• value1, value2, etc.: Los valores constantes con los que se compara la expresión.
• break: Termina el bloque de casos actual para evitar que se caiga.
• default: Opcional; se ejecuta si no coincide ningún case.

Ejemplos

Ejemplo 1: Uso básico

public class SwitchExample {
    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;
            case 4:
                System.out.println("Thursday");
                break;
            case 5:
                System.out.println("Friday");
                break;
            case 6:
                System.out.println("Saturday");
                break;
            case 7:
                System.out.println("Sunday");
                break;
            default:
                System.out.println("Invalid day");
        }
    }
}

En este ejemplo, la sentencia switch evalúa el valor de day. Como day es 3, se ejecuta el bloque de código de case 3, que imprime "miércoles".

Ejemplo 2: Utilizar cadenas en Switch

public class SwitchStringExample {
    public static void main(String[] args) {
        String fruit = "Apple";
        switch (fruit) {
            case "Apple":
                System.out.println("Apple is red.");
                break;
            case "Banana":
                System.out.println("Banana is yellow.");
                break;
            case "Orange":
                System.out.println("Orange is orange.");
                break;
            default:
                System.out.println("Unknown fruit.");
        }
    }
}

Este ejemplo demuestra el uso de una sentencia switch con una String. La sentencia switch evalúa el valor de fruit. Como fruit es "Manzana", imprime "Manzana es roja".

Ejemplo 3: Comportamiento Fall-through

public class FallThroughExample {
    public static void main(String[] args) {
        int num = 2;
        switch (num) {
            case 1:
                System.out.println("One");
            case 2:
                System.out.println("Two");
            case 3:
                System.out.println("Three");
                break;
            default:
                System.out.println("Default");
        }
    }
}

En este ejemplo, la sentencia switch evalúa el valor de num. Como num es 2, imprime "Dos" y luego sigue ejecutando "Tres" porque no hay ninguna sentencia break después de case 2.

Ejemplo 4: Sentencias de conmutación anidadas

public class NestedSwitchExample {
    public static void main(String[] args) {
        int outer = 1;
        int inner = 2;
        switch (outer) {
            case 1:
                switch (inner) {
                    case 1:
                        System.out.println("Inner 1");
                        break;
                    case 2:
                        System.out.println("Inner 2");
                        break;
                }
                break;
            case 2:
                System.out.println("Outer 2");
                break;
            default:
                System.out.println("Default Outer");
        }
    }
}

Este ejemplo demuestra el uso de una sentencia switch anidada. La sentencia externa switch evalúa el valor de outer, mientras que la sentencia interna switch evalúa el valor de inner.

Consejos y buenas prácticas

• Utiliza siempre break: Utiliza la declaración break para evitar el comportamiento "fall-through" a menos que se desee explícitamente.
• Caso por defecto: Incluye siempre un caso default para manejar valores inesperados.
• Valores constantes: Asegúrate de que las etiquetas case son constantes y únicas dentro de la sentencia switch.
• Tipos de datos: Las declaraciones switch pueden utilizarse con los tipos byte, short, int, char, String y enum.
• Simplifica el Código: Utiliza las declaraciones switch para simplificar el código que implica múltiples condiciones, haciéndolo más legible y fácil de mantener.
• Evita null en Switch: Ten cuidado con los valores de null en las expresiones de conmutación para evitar NullPointerException.

switch (expression) {
    case constant1:
        // code block
        break;
    case constant2:
        // code block
        break;
    // more cases...
    default:
        // default code block
}