En la entrada anterior ya hemos visto cómo funcionan las estructuras condicionales en Java 8, incluyendo el operador ternario y la sentencia switch tradicional (la que existe desde Java 8 y antes). Es una herramienta útil, pero todos los que la hemos usado conocemos sus «peligros»:

1. Es muy verbosa, poco legible: repite break por todas partes.
2. Es propensa a errores. ¿Quién no ha olvidado un break provocando que se ejecuten varios casos por error?

Afortunadamente, a partir de Java 14 la sentencia switch recibió una de las mejoras más importantes de su historia. Ya no es solo una sentencia (que da órdenes), sino que también puede actuar como una expresión (que devuelve un valor).

Vamos a ver qué significa esto y cómo cambia para siempre nuestra forma de usarlo.

1. El switch «clásico» (como recordatorio) 📜

Antes de Java 14, si queríamos asignar un valor a una variable basándonos en otra, el código era verboso. Por ejemplo, para obtener el número de días de un mes:

// Código "clásico" con Java 8
int mes = 2; // Mes: Febrero
int dias;

switch (mes) {
    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
    case 10:
    case 12:
        dias = 31;
        break;
    case 4:
    case 6:
    case 9:
    case 11:
        dias = 30;
        break;
    case 2:
        dias = 28; // Ignoremos los bisiestos por simplicidad
        break;
    default:
        dias = -1; // Valor para indicar un error
        break;
}

System.out.println("El mes tiene " + dias + " días.");

Este código funciona, pero es aparatoso. Necesitamos una variable dias declarada fuera y un break por cada grupo de casos.

2. Novedad 1: El switch como expresión y la sintaxis de flecha (->) 🚀

La primera gran novedad es que el switch entero puede devolver un valor. Esto significa que podemos ponerlo a la derecha de una asignación (=).

Para que esto funcione, se introduce una nueva sintaxis:

• Cambiamos los dos puntos (:) por una flecha (->).
• Lo que está a la derecha de la flecha es lo que se devuelve.
• ¡No se necesita break! La flecha solo ejecuta su línea, eliminando por completo el error de «fall-through».

Ahora, veamos el ejemplo anterior reescrito con la sintaxis de Java 14:

Java

// Código "moderno" con Java 14
int mes = 2;

// El switch entero AHORA devuelve un valor que asignamos a 'dias'
int dias = switch (mes) {
    case 1, 3, 5, 7, 8, 10, 12 -> 31; // Múltiples casos en una línea
    case 4, 6, 9, 11 -> 30;
    case 2 -> 28;
    default -> -1;
}; // ¡Ojo! Se necesita un punto y coma aquí, porque es una expresión.

System.out.println("El mes tiene " + dias + " días.");

El resultado es radicalmente distinto:

• El código es más limpio y conciso.
• Es más seguro, ya que es imposible olvidarse un break.
• Queda más claro que la variable dias obtendrá siempre un valor.

3. Novedad 2, la palabra yield: cuando necesitas un bloque de código 🧱

La sintaxis de flecha (->) es fantástica para devolver un valor simple. Pero, ¿y si necesitamos ejecutar varias líneas de código (un bloque {...}) antes de devolver el valor?

Por ejemplo, si para el caso 2 (Febrero) quisiéramos imprimir un mensaje además de devolver el 28. Si usamos un bloque {...}, ¿cómo le decimos qué valor debe devolver?

Para esto, Java 14 introduce la palabra clave yield.

yield actúa como el «return» de un bloque case dentro de un switch expresión.

// Código con 'yield' para bloques
int mes = 2;

int dias = switch (mes) {
    case 1, 3, 5, 7, 8, 10, 12 -> 31;
    case 4, 6, 9, 11 -> 30;
    case 2 -> {
        // Podemos tener un bloque de código completo
        System.out.println("Es febrero, el mes más corto.");
        // Usamos 'yield' para devolver el valor de este bloque
        yield 28; 
    }
    default -> {
        System.out.println("Error: Mes no válido.");
        yield -1;
    }
};

System.out.println("El mes tiene " + dias + " días.");

Importante: No puedes mezclar las dos sintaxis en el mismo switch. O usas case L: ... break; (la forma antigua) o usas case L -> ... ; y case L { yield V; } (la forma moderna).

Conclusión ✅

Los cambios del switch en Java 14 no son solo un retoque estético; son una modernización fundamental que nos permite escribir código más seguro, expresivo y legible.

• switch como expresión: Permite que el switch devuelva un valor.
• Sintaxis ->: Elimina la necesidad de break y el error de «fall-through».
• yield: Es la palabra clave para devolver un valor cuando usamos un bloque {...} en un case moderno.

Siempre que tu versión de Java te lo permita, esta debería ser tu forma preferida de usar switch.