Expresiones switch avanzadas

1. Qué hay de nuevo en switch

Si por casualidad programaste en Java antes de la versión 14, switch se veía más o menos así:

switch (day) 
{
    case MONDAY:
        System.out.println("¡Inicio de la semana!");
        break;
    case FRIDAY:
        System.out.println("¡Viernes, hurra!");
        break;
    default:
        System.out.println("Un día normal.");
        break;
}

Parece que no pasa nada grave, pero:

• Hay que no olvidarse de break (de lo contrario «caeremos» al siguiente case).
• Mucho código repetido.
• Si quieres devolver un valor, tienes que declarar la variable de antemano y asignarle un valor dentro de cada case.

Java 14+ decidió: ¡basta! Es hora de hacer que switch sea más cómodo y moderno.

Novedades principales:

• Switch se convirtió en una expresión, y no solo en una instrucción — ahora puede devolver un valor.
• Nueva sintaxis con flecha -> en lugar de dos puntos y break.
• Varios case separados por comas — para la misma lógica.
• El compilador comprueba que se han cubierto todas las variantes (especialmente con enum).
• No hay riesgo de «fall-through» — ahora solo es posible de forma explícita.

2. Sintaxis de la expresión switch

switch (znachenie)
{
   case A, B -> rezultat1;
   case C -> {
      // varias acciones
      yield rezultat2;
   }
   default -> rezultatPoUmolchaniyu;
}

Ejemplo básico

Vamos al grano. Así se puede devolver un valor desde switch ahora:

DayOfWeek day = DayOfWeek.MONDAY;

String message = switch (day) 
{
    case MONDAY, FRIDAY, SUNDAY -> "¡Semana corta o festivo!";
    case TUESDAY                -> "El martes es un día duro.";
    case WEDNESDAY, THURSDAY    -> "¡Mitad de la semana!";
    case SATURDAY               -> "¡Hurra, sábado!";
    // default es obligatorio si no se han cubierto todos los casos
    default                     -> "Un día algo raro...";
};

System.out.println(message);

Qué está pasando aquí:

• switch (day) — una expresión que devuelve un valor.
• Después de la flecha -> se indica el resultado para ese case.
• Se pueden unir varios case separados por comas.
• No hay ningún break — Java sabe sola dónde termina la rama.
• Se puede asignar directamente el resultado a la variable message.

Ejemplo con números

int code = 404;
String result = switch (code) 
{
    case 200 -> "OK";
    case 400, 404 -> "Error del cliente";
    case 500 -> "Error del servidor";
    default -> "Código desconocido";
};
System.out.println(result);

Ejemplo con cadenas

String command = "start";
String status = switch (command) 
{
    case "start" -> "¡Inicio!";
    case "stop" -> "¡Parada!";
    case "pause" -> "Pausa...";
    default -> "Comando desconocido";
};
System.out.println(status);

Uso de un bloque con yield

A veces queremos ejecutar varias acciones para un case (por ejemplo, calcular algo complejo o hacer logging). Para ello se puede usar un bloque { ... } y la palabra clave yield:

int n = 7;
String parity = switch (n % 2) 
{
    case 0 -> "Par";
    case 1 -> 
    {
        System.out.println("Se ha detectado un número impar: " + n);
        yield "Impar";
    }
    default -> "Algo extraño";
};
System.out.println(parity);

Importante: en el bloque debe haber obligatoriamente un yield, que devuelve el valor para ese case.

3. Ventajas de la nueva sintaxis

No hace falta break

En el switch clásico, olvidarse de break es fuente de dolor y bugs misteriosos. En la nueva sintaxis, break no hace falta en absoluto: cada rama termina automáticamente.

El compilador comprueba el tratamiento de todas las variantes

Si usas enum y no has tratado todos los valores, el compilador no permitirá compilar el proyecto sin default. Esto hace el código más fiable.

No hay «fall-through»

En el switch clásico, si olvidas break, la ejecución «caerá» al siguiente case. En la nueva sintaxis esto es imposible (a menos que uses un bloque con instrucciones y escribas explícitamente break — pero aquí no hace falta).

Código más compacto y legible

Compáralo tú mismo:

Antes:

String result;
switch (status) {
    case "OK":
        result = "Todo bien";
        break;
    case "ERROR":
        result = "Error";
        break;
    default:
        result = "Desconocido";
        break;
}

Después:

String result = switch (status) {
    case "OK" -> "Todo bien";
    case "ERROR" -> "Error";
    default -> "Desconocido";
};

Varios case — una sola lógica

case MONDAY, FRIDAY, SUNDAY -> "¡Festivo o día corto!";

4. Comparación con el switch clásico

5. Compatibilidad con enum y cadenas

Ejemplo con enum

Supongamos que tenemos una enumeración:

enum DayOfWeek 
{
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

La usamos en el nuevo switch:

DayOfWeek today = DayOfWeek.WEDNESDAY;

String mood = switch (today) 
{
    case MONDAY -> "Cuesta levantarse...";
    case FRIDAY -> "¡Pronto, el fin de semana!";
    case SATURDAY, SUNDAY -> "¡Hurra, descanso!";
    default -> "Día laborable.";
};
System.out.println(mood);

Ejemplo con String

String season = "summer";
String activity = switch (season) 
{
    case "winter" -> "Patinar sobre hielo";
    case "summer" -> "Nadar en el lago";
    case "autumn" -> "Recolectar setas";
    case "spring" -> "Escuchar el canto de los pájaros";
    default -> "Estación desconocida";
};
System.out.println(activity);

6. Reescribimos el switch antiguo al estilo nuevo

Antes:

int day = 3;
String dayName;
switch (day) 
{
    case 1:
        dayName = "Lunes";
        break;
    case 2:
        dayName = "Martes";
        break;
    case 3:
        dayName = "Miércoles";
        break;
    default:
        dayName = "Día desconocido";
        break;
}
System.out.println(dayName);

Después:

int day = 3;
String dayName = switch (day) 
{
    case 1 -> "Lunes";
    case 2 -> "Martes";
    case 3 -> "Miércoles";
    default -> "Día desconocido";
};
System.out.println(dayName);

Otro ejemplo: varios case — una sola lógica

int score = 5;
String grade = switch (score) 
{
    case 5, 6, 7 -> "Bien";
    case 8, 9, 10 -> "Excelente";
    default -> "Hay que esforzarse";
};
System.out.println(grade);

7. Errores típicos y particularidades

Error n.º 1: falta de default si no se han tratado todas las variantes. Si usas una switch-expresión con un tipo que puede tener valores fuera de los case enumerados (por ejemplo, con int o String), el compilador exigirá default. Para enum, si no has tratado todos los valores, default también es obligatorio.

Error n.º 2: olvido de yield en el bloque. Si usas llaves para un case (hay que ejecutar varias acciones), no olvides yield — sin él el compilador dará el error: "Missing yield statement".

Error n.º 3: desajuste de tipos. Todas las ramas de la switch-expresión deben devolver valores del mismo tipo; de lo contrario, el compilador no aceptará el código.

Error n.º 4: duplicación de valores case. No se puede indicar el mismo case dos veces — el compilador informará del error de inmediato.

1

Cuestionario/control

Constantes, enum y switch, nivel 10, lección 5

No disponible

Constantes, enum y switch

Constantes, enum y switch

Abrir