Aunque realmente las nuevas switch expressions no son una novedad reciente, ya que están disponibles desde la versión 14 de Java, es otra de esas mejoras que pasan desapercibidas aunque, con un pequeño cambio de sintaxis, proporcionan una versión moderna, limpia, segura y expresiva de los tradicionales switch.

¿Qué aporta el switch moderno?

1. Es una expresión, no solo una sentencia

El nuevo switch puede devolver valores directamente a una variable haciendo uso del operador flecha.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

String day = switch (dayOfWeek) {
    case 1 -> "Monday";
    case 2 -> "Tuesday";
    case 3 -> "Wednesday";
    case 4 -> "Thursday";
    case 5 -> "Friday";
    case 6 -> "Saturday";
    case 7 -> "Sunday";
    default -> "Invalid day";
};

2. Evita el ‘fall-through’

En los tradicionales switch, si te olvidabas un break provocaba la ejecución de varios case. Ahora ya no son necesarios, eliminado verbosidad y aportando robustez y permitiendo igualmente agrupar casos.

1
2
3
4
5

String dayType = switch (dayOfWeek) {
    case 1, 2, 3, 4, 5 -> "Weekday";
    case 6, 7 -> "Weekend";
    default -> "Invalid";
};

3. Menos código y más claro

En el switch clásico, había que declarar la variable, abrir el switch, asignar valor en cada case, acordarte de los break y cerrar la expresión correctamente.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

String day;

switch (dayOfWeek) {
    case 1:
        day = "Monday";
        break;
    case 2:
        day = "Tuesday";
        break;
    case 3:
        day = "Wednesday";
        break;
    case 4:
        day = "Thursday";
        break;
    case 5:
        day = "Friday";
        break;
    case 6:
        day = "Saturday";
        break;
    case 7:
        day = "Sunday";
        break;
    default:
        day = "Invalid day";
}

4. Uso de ‘yield’ para casos más complejos

Se trata de un nuevo operador, un return que sólo existe dentro de las nuevas switch expressions, y que no finaliza la ejecución del método. Permite desarrollar un case más complejo y devolver un valor en el mismo.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

double price = switch (customerType) {

    case STANDARD -> basePrice;

    case PREMIUM -> {
        double discount = basePrice * 0.10;
        if (discount > 30) {
            System.out.println("Aplicando tope de descuento");
            discount = 30;
        }
        yield basePrice - discount;
    }

    case STUDENT -> basePrice * 0.85;

    default -> basePrice;
};

5. Switch más exhaustivos usando Enums

Otra mejora interesante, disponible desde Java 17, es el uso de Enums para definir los case. De esta forma el desarrollador está obligado a usar todos sus valores, obteniendo un aviso del compilador en caso contrario.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public enum CustomerType {  
    REGULAR, SILVER, GOLD, PLATINUM, DIAMOND;  
}  
  
public double calculateDiscount(CustomerType type, double amount) {  
    return switch (type) {  
        case REGULAR -> 0.0;  
        case SILVER  -> amount * 0.05;  
        case GOLD    -> amount * 0.10;  
  
        case PLATINUM -> {  
            System.out.println("Aplicando descuento especial");  
            double bonus = amount > 1000 ? 0.02 : 0.0;  
            yield amount * (0.15 + bonus);  
        }  
    };  
}

Conclusiones

Las nuevas switch expressions no cambian la forma de pensar en condiciones, pero sí nos permite expresarlas con menos ruido y más seguridad. Es una pieza pequeña, pero encaja muy bien en el Java moderno: más conciso, más claro y más difícil de romper por descuido.