Sentencia switch en Java: casos, fall-through y sintaxis de flecha

Para qué sirve switch

Un switch compara un valor contra una lista de opciones fijas y ejecuta la rama que coincide. Cuando te encuentras escribiendo una larga cadena if/else if que sigue comprobando la misma variable contra distintas constantes, un switch dice lo mismo con más claridad.

Solo realiza comprobaciones de igualdad contra constantes de tiempo de compilación: no puede comprobar rangos ni combinar condiciones. Para eso, sigue con if/else.

La sentencia switch clásica

La forma tradicional usa etiquetas case con dos puntos y un break después de cada rama:

public class Main {
    public static void main(String[] args) {
        int day = 3;

        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            default:
                System.out.println("Some other day");
        }
    }
}

Java evalúa day, salta al case que coincide, ejecuta sus instrucciones, y el break sale del switch. La rama default se ejecuta cuando nada más coincide: piénsala como el else. Es opcional, pero incluirla es buena práctica para que los valores inesperados no se cuelen en silencio.

La trampa del break: el fall-through

Este es el error de switch más común de todos. Si omites un break, la ejecución no se detiene al final de un case que coincide: cae en el siguiente case y sigue ejecutándose hasta que encuentra un break o la llave de cierre:

public class Main {
    public static void main(String[] args) {
        int level = 1;

        switch (level) {
            case 1:
                System.out.println("Level 1");
                // no break - falls through!
            case 2:
                System.out.println("Level 2");
            case 3:
                System.out.println("Level 3");
                break;
        }
    }
}

Podrías esperar solo Level 1, pero esto imprime las tres líneas. Como case 1 no tiene break, el control se desliza directamente hacia case 2 y case 3. Añade siempre break a menos que realmente quieras el fall-through, y cuando dependas de él, deja un comentario para que el siguiente lector sepa que fue intencional.

Agrupar casos

El fall-through tiene un uso legítimo y ordenado: apilar etiquetas case para que varios valores compartan un mismo bloque. Pon las etiquetas una tras otra sin código entre ellas:

public class Main {
    public static void main(String[] args) {
        char grade = 'B';

        switch (grade) {
            case 'A':
            case 'B':
            case 'C':
                System.out.println("Pass");
                break;
            case 'D':
            case 'F':
                System.out.println("Fail");
                break;
            default:
                System.out.println("Unknown grade");
        }
    }
}

Aquí 'A', 'B' y 'C' ejecutan todos la misma línea "Pass". Esta es la forma prevista de decir "cualquiera de estos valores hace lo mismo".

switch sobre cadenas

No estás limitado a números. Desde Java 7 puedes hacer switch sobre un String, lo cual es perfecto para opciones de menú o nombres de comandos:

public class Main {
    public static void main(String[] args) {
        String command = "stop";

        switch (command) {
            case "start":
                System.out.println("Starting...");
                break;
            case "stop":
                System.out.println("Stopping...");
                break;
            default:
                System.out.println("Unknown command: " + command);
        }
    }
}

La comparación distingue mayúsculas de minúsculas: "Stop" no coincidiría con "stop", así que normaliza primero (por ejemplo, command.toLowerCase()) si la capitalización de la entrada varía. Un detalle más: si command es null, el switch lanza una NullPointerException, así que protégete contra null antes de llegar a él.

La moderna sintaxis de flecha

Java más reciente (14+) añade una forma con flecha, case label -> ..., que corrige por diseño la trampa del fall-through. Cada case de flecha ejecuta exactamente una rama y nunca cae, así que no hay ningún break que olvidar:

public class Main {
    public static void main(String[] args) {
        int day = 6;

        switch (day) {
            case 1, 2, 3, 4, 5 -> System.out.println("Weekday");
            case 6, 7          -> System.out.println("Weekend");
            default            -> System.out.println("Invalid day");
        }
    }
}

Fíjate en que agrupas valores con una coma (case 6, 7) en lugar de apilar etiquetas, y no hay ni un solo break a la vista. Para varias instrucciones, usa un bloque: case 1 -> { ...; ... }. Prefiere esta forma en el código nuevo: es más corta y elimina toda una clase de errores.

switch como expresión

La forma con flecha también puede producir un valor. Una expresión switch devuelve un resultado que puedes asignar directamente a una variable: sin temporal, sin asignación repetida en cada rama:

public class Main {
    public static void main(String[] args) {
        int month = 4;

        int days = switch (month) {
            case 1, 3, 5, 7, 8, 10, 12 -> 31;
            case 4, 6, 9, 11           -> 30;
            case 2                     -> 28;
            default -> throw new IllegalArgumentException("Bad month: " + month);
        };

        System.out.println("Days: " + days);
    }
}

Todo el switch (...) { ... } se evalúa a un número almacenado en days. Observa el punto y coma después de la llave de cierre: es parte de la instrucción de asignación. Una expresión switch debe ser exhaustiva (cubrir todos los valores posibles), por eso está aquí el default. Si una rama necesita varias instrucciones antes de devolver un valor, usa un bloque con yield:

case 2 -> {
    boolean leap = (year % 4 == 0);
    yield leap ? 29 : 28;
}

yield es la forma en que un bloque de flecha devuelve su valor, el equivalente en el mundo de las expresiones del break que lleva un resultado.

Siguiente: bucles for

switch elige una rama entre muchas; a veces, en cambio, necesitas repetir un bloque muchas veces. El bucle for ejecuta código un número controlado de veces (recorriendo un rango o pasando por cada elemento) y es la siguiente página.