Java Academy · Lección

Casos con varias etiquetas

Agrupe varias etiquetas

Casos con varias etiquetas es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Agrupar etiquetas

A menudo, varios valores deben activar la misma acción. El switch moderno permite enumerar varias etiquetas en un mismo caso, separadas por comas, para compartir una sola rama.

Etiquetas separadas por comas

Escriba los valores uno tras otro, separados por comas, antes de ->. Si alguno coincide, se ejecuta la rama.

public class Main {
    public static void main(String[] args) {
        int day = 7;
        switch (day) {
            case 1, 2, 3, 4, 5 -> System.out.println("Weekday");
            case 6, 7 -> System.out.println("Weekend");
        }
    }
}

Detección de vocales

Un uso clásico consiste en agrupar todas las vocales en una sola rama en lugar de escribir cinco casos separados.

public class Main {
    public static void main(String[] args) {
        char c = 'o';
        switch (c) {
            case 'a', 'e', 'i', 'o', 'u' -> System.out.println("Vowel");
            default -> System.out.println("Consonant");
        }
    }
}

Varias etiquetas en expresiones

Los casos con varias etiquetas también funcionan en expresiones switch y devuelven el mismo valor para cualquiera de las etiquetas indicadas.

public class Main {
    public static void main(String[] args) {
        int month = 7;
        String season = switch (month) {
            case 12, 1, 2 -> "Winter";
            case 3, 4, 5 -> "Spring";
            case 6, 7, 8 -> "Summer";
            default -> "Autumn";
        };
        System.out.println(season);
    }
}

Agrupar etiquetas de String

También puede agrupar valores String. Aquí, varias formas de escribir un comando se asignan a una sola acción.

public class Main {
    public static void main(String[] args) {
        String cmd = "quit";
        switch (cmd) {
            case "quit", "exit", "q" -> System.out.println("Closing");
            case "help", "h" -> System.out.println("Showing help");
            default -> System.out.println("Unknown command");
        }
    }
}

Agrupar etiquetas de enum

Las constantes de un enum también pueden compartir una rama, lo que mantiene compacta la lógica de categorías.

public class Main {
    enum Day { MON, TUE, WED, THU, FRI, SAT, SUN }
    public static void main(String[] args) {
        Day d = Day.SAT;
        String kind = switch (d) {
            case SAT, SUN -> "Rest";
            default -> "Work";
        };
        System.out.println(kind);
    }
}

No se permiten etiquetas duplicadas

Cada etiqueta puede aparecer una sola vez en todo el switch. Enumerar el mismo valor en dos ramas provoca un error de compilación, porque el compilador no podría decidir qué rama ejecutar.

public class Main {
    public static void main(String[] args) {
        int n = 2;
        switch (n) {
            case 1, 2 -> System.out.println("Low");
            case 3, 4 -> System.out.println("High");
            default -> System.out.println("Other");
        }
    }
}

Comparación con el antiguo fall-through

En el antiguo estilo con dos puntos, para agrupar casos era necesario apilar casos con fall-through intencionado y sin cuerpo sobre un único cuerpo compartido. La sintaxis con comas es mucho más clara y evita el fall-through accidental.

public class Main {
    public static void main(String[] args) {
        int code = 3;
        switch (code) {
            case 1, 3, 5, 7, 9 -> System.out.println("Odd");
            case 0, 2, 4, 6, 8 -> System.out.println("Even");
        }
    }
}

Agrupar con bloques

Un caso agrupado también puede utilizar un cuerpo de bloque. Cualquiera de las etiquetas coincidentes ejecuta el bloque completo.

public class Main {
    public static void main(String[] args) {
        char grade = 'B';
        switch (grade) {
            case 'A', 'B' -> {
                System.out.println("Pass");
                System.out.println("Well done");
            }
            default -> System.out.println("Try again");
        }
    }
}

Combinar con yield

Las etiquetas agrupadas y yield funcionan juntas cuando una rama compartida necesita realizar cálculos.

public class Main {
    public static void main(String[] args) {
        int n = 4;
        int points = switch (n) {
            case 1, 2, 3 -> 10;
            case 4, 5, 6 -> {
                int bonus = n * 2;
                yield 20 + bonus;
            }
            default -> 0;
        };
        System.out.println(points);
    }
}

Una mejora de legibilidad

Los casos con varias etiquetas reducen largas listas de ramas repetitivas a unos pocos grupos claros, haciendo evidente la intención de un vistazo.

public class Main {
    public static void main(String[] args) {
        int http = 204;
        String group = switch (http / 100) {
            case 1, 2, 3 -> "OK-ish";
            case 4, 5 -> "Error";
            default -> "Unknown";
        };
        System.out.println(group);
    }
}

Comprobación rápida

¿Cómo se consigue que varios valores ejecuten la misma rama de switch en Java moderno?

Repaso

Ha aprendido a utilizar casos con varias etiquetas:

Enumere los valores separados por comas antes de ->
Funciona con enteros, caracteres, Strings y enums
No hay fall-through accidental, a diferencia del estilo antiguo
Cada etiqueta puede aparecer una sola vez
Combínelos con bloques y yield cuando sea necesario

Preguntas frecuentes

¿La lección «Casos con varias etiquetas» es gratis?

Sí — el texto completo de «Casos con varias etiquetas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Casos con varias etiquetas»?

Agrupe varias etiquetas Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Casos con varias etiquetas»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Java Academy