Switch expressions

Del switch clásico al switch moderno

El switch tradicional de Java es una sentencia (statement): ejecuta bloques de código. Tenía dos problemas clásicos: el fallthrough (si olvidas break, la ejecución cae en el siguiente case) y no podía devolver un valor directamente.

// Switch clásico: statement, fallthrough, propenso a errores
String dia;
switch (numero) {
    case 1:
    dia = "Lunes";
    break;
    case 2:
    dia = "Martes";
    break;
    case 3:
    dia = "Miércoles";
    break;
    default:
    dia = "Desconocido";
}

A partir de Java 14 existe el switch como expresión (expression) con sintaxis de flecha, que devuelve un valor y elimina el fallthrough:

// Switch expression: devuelve valor, sin break, sin fallthrough
String dia = switch (numero) {
    case 1 -> "Lunes";
    case 2 -> "Martes";
    case 3 -> "Miércoles";
    default -> "Desconocido";
};

Sintaxis con flecha ->

La flecha convierte cada rama en una expresión independiente sin fallthrough. No se necesita break y el valor de la derecha es el resultado de la expresión switch.

int diasDelMes = switch (mes) {
    case 1, 3, 5, 7, 8, 10, 12 -> 31;
    case 4, 6, 9, 11 -> 30;
    case 2 -> esBisiesto(año) ? 29 : 28;
    default -> throw new IllegalArgumentException("mes inválido: " + mes);
};

Observa:

• Múltiples etiquetas en el mismo case separadas por coma: case 1, 3, 5 ->.
• La rama default puede lanzar una excepción: es una expresión válida en Java.
• Punto y coma al final del switch, no al final de cada rama.

Bloques y yield

Si una rama necesita varias sentencias, se usa un bloque { } y la palabra clave yield para devolver el valor:

String descripcion = switch (codigo) {
    case "A" -> "Categoría A";
    case "B", "C" -> "Categoría B o C";
    case "Z" -> {
        System.out.println("Procesando Z...");
        String resultado = cargarDatosZ();
        yield "Especial: " + resultado;
    }
    default -> "Desconocida";
};

yield es solo válido dentro de bloques en un switch expression. No es una palabra reservada global: puedes tener variables llamadas yield en otros contextos.

Switch statement con sintaxis de flecha

La flecha también puede usarse con switch como sentencia (sin devolver valor). En ese caso se usa para ejecutar acciones sin fallthrough:

switch (evento) {
    case "LOGIN" -> registrarLogin();
    case "LOGOUT" -> registrarLogout();
    case "ERROR" -> registrarError();
    default -> { /* no hacer nada */ }
}

Exhaustividad

Un switch expression debe ser exhaustivo: todas las entradas posibles deben estar cubiertas. Si el tipo del selector tiene un dominio cerrado (enum, sealed class), el compilador lo verifica y puede omitirse default.

Con enum:

enum Prioridad { BAJA, MEDIA, ALTA, CRITICA }

int puntuacion = switch (prioridad) {
    case BAJA -> 1;
    case MEDIA -> 5;
    case ALTA -> 8;
    case CRITICA -> 10;
};
// No se necesita default: el compilador sabe que todas las enum constants están cubiertas

Si se añade una nueva constante al enum y no se actualiza el switch, el compilador avisa con error. Esto es muy útil para detectar código obsoleto.

Con tipos abiertos (int, String, Object...), default es obligatorio en switch expressions.

Patrones modernos en casos reales

Mapeo 1-a-1 con múltiples etiquetas

boolean esFinDeSemana = switch (diaSemana) {
    case SABADO, DOMINGO -> true;
    case LUNES, MARTES, MIERCOLES, JUEVES, VIERNES -> false;
};

Tabla de despacho limpia

record Operacion(String nombre, int a, int b) {}

int calcular(Operacion op) {
    return switch (op.nombre()) {
        case "sumar" -> op.a() + op.b();
        case "restar" -> op.a() - op.b();
        case "mult" -> op.a() * op.b();
        case "div" -> op.b() == 0
        ? throw new ArithmeticException("división por cero")
        : op.a() / op.b();
        default -> throw new IllegalArgumentException("op desconocida: " + op.nombre());
    };
}

Dentro de un return

public String procesar(Estado estado) {
    return switch (estado) {
        case ACTIVO -> "activo";
        case PAUSADO -> "pausado";
        case CERRADO -> "cerrado";
    };
}

Tabla comparativa

| Aspecto | Switch clásico (:) | Switch moderno (->) | |---------|--------------------:|:---------------------:| | Fallthrough | Sí (olvido de break) | No | | Devuelve valor | No (solo statement) | Sí (expression) | | Etiquetas múltiples | case 1: case 2: separados | case 1, 2 -> | | Devolver desde bloque | No directo | yield | | Exhaustividad | No obligatoria | Obligatoria en expression | | Bugs típicos | Muy habituales | Casi imposibles |

Buenas prácticas

• Usa -> siempre que escribas código nuevo. Es más seguro y conciso.
• Prefiere switch expression cuando el resultado es un valor único.
• Combina con sealed interface + record para switches totalmente exhaustivos verificados en compilación.
• Si tienes muchas etiquetas que producen el mismo resultado, agrúpalas con coma en lugar de repetir.
• yield dentro de bloques es la forma correcta; no intentes usar return (solo saldría del método, no del switch).

Los switch expressions son la puerta de entrada al pattern matching con switch (Java 21), que veremos en el curso de POO y permite case Integer i when i > 0 -> ....