Instrucciones switch en

Acerca de Instrucciones switch

Igual que una instrucción if/else, una instrucción switch te permite cambiar el flujo del programa ejecutando código de forma condicional. La diferencia es que una instrucción switch solo puede comparar el valor de una expresión primitiva o de tipo string con valores constantes predefinidos.

Algunas palabras clave resultan útiles cuando usas una instrucción switch.

• switch: esta palabra clave te permite declarar la estructura del switch. Va seguida de la expresión o la variable que hará que cambie el resultado.
• case: la usarás para declarar las distintas posibilidades del resultado.
• break: la palabra clave break es muy útil para detener la ejecución del switch al final del flujo deseado. Si la olvidas, el programa continuará y puede dar lugar a resultados inesperados.
• default: como su nombre indica, úsala como resultado predeterminado cuando ningún otro case coincida con el resultado de tu expresión.

En su forma más simple, evalúan una expresión primitiva o de tipo string y toman una decisión basándose en su valor. Por ejemplo:

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

A partir de Java 14 (disponible como vista previa antes, en Java 12 y 13) es posible usar la implementación «mejorada» del switch.

1. Tienes la posibilidad de asignar varios valores en un solo case. En la instrucción switch tradicional puedes usar el fall-through. En el siguiente ejemplo, case 1 y case 3 ejecutarán lo mismo. Esto se consigue porque case 1 no usa la palabra clave break.

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

   En la switch expression mejorada puedes asignar varios valores directamente a un case. Fíjate en el siguiente ejemplo:

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

2. Ahora puedes escribir una switch-statement o una switch expression. ¿Cuál es la diferencia? Básicamente, una instrucción espera una lógica estricta, mientras que una expresión puede devolver un valor. En lugar de:

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

   Puedes hacer:

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

   La yield funciona igual que un return, excepto que es para la switch expression. Como yield termina la expresión, aquí no se necesita break.

3. Otra diferencia entre las switch statements y las switch expressions: en las switch expressions DEBES cubrir todos los casos. Ya sea teniendo un case para todos los valores posibles o usando un case default.

4. Puedes usar -> en lugar de :. El -> te permite no incluir la palabra clave break. Se pueden usar ambas notaciones, pero en un mismo switch tienes que ceñirte a una sola.

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

5. El scope. El switch tradicional puede dar lugar a comportamientos inesperados debido a su scope, ya que hay un único scope para todo el switch.

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

   Este ejemplo no funciona porque message se declara dos veces dentro del switch. Se podría solucionar así:

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

   Ya que las {} delimitan el scope del case. Sin embargo, no es intuitivo porque las {} no son obligatorias. Pero si usas la nueva notación ->, debe ir seguida de una de estas cosas: una única instrucción o expresión, una instrucción throw o un bloque {}. ¡Se acabó la confusión!

Puedes encontrar más información sobre el switch mejorado en este artículo y este otro, junto con la documentación oficial de Oracle.

Además, en Java 21 se añadió una funcionalidad llamada Guarded Patterns, que te permite hacer comprobaciones en la propia etiqueta del 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";
};

Puedes encontrar más información sobre la switch expression en Java 21 en este blog