Sentencias switch en

Acerca de Sentencias switch

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

Algunas palabras clave son útiles cuando usas una sentencia switch.

• switch: esta palabra clave te permite declarar la estructura del switch. Va seguida de la expresión o la variable que hará cambiar 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 que quieres. Si la olvidas, el programa continuará y puede dar resultados inesperados.
• default: como su nombre lo 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 sentencia switch tradicional puedes usar el fall-through. En el siguiente ejemplo, case 1 y case 3 ejecutarán lo mismo. Esto se logra 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 expresión switch expression mejorada puedes asignar varios valores directamente a un case. Mira 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 sentencia 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 como un return, salvo que es para una expresión switch. Como yield termina la expresión, aquí no se necesita break.

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

4. Puedes usar -> en lugar de :. El -> te permite no incluir la palabra clave break. Ambas notaciones se pueden usar, pero en un switch tienes que quedarte con 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 ámbito. El switch tradicional puede provocar comportamientos inesperados por su ámbito, ya que hay un solo ámbito 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 en el switch. Se podría resolver usando:

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

   Como las {} delimitan el ámbito del case. Sin embargo, no es intuitivo porque las {} no son obligatorias. Pero si usas la nueva notación ->, esta debe ir seguida de: una sola sentencia o expresión, una sentencia 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 agregó 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 expresión switch en Java 21 en este blog