Java Academy · Lección

Expresiones switch con enumeraciones

Use expresiones switch modernas con enumeraciones para crear ramificaciones claras y exhaustivas.

Expresiones switch con enumeraciones es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 3 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.

Expresiones switch con enumeraciones

Las expresiones switch (Java 14+) con enumeraciones proporcionan una selección concisa y exhaustiva basada en tipos. Cuando se cubren todas las constantes de la enumeración, no es necesario utilizar default.

Instrucción switch tradicional

La instrucción switch clásica funciona con enumeraciones, pero requiere break para evitar la ejecución en cascada.

enum Severity { LOW, MEDIUM, HIGH, CRITICAL }

Severity s = Severity.HIGH;
String action;
switch (s) {
    case LOW:
        action = "Log and monitor";
        break;
    case MEDIUM:
        action = "Notify on-call team";
        break;
    case HIGH:
        action = "Page engineer immediately";
        break;
    case CRITICAL:
        action = "Activate incident response";
        break;
    default:
        action = "Unknown";
}
System.out.println(action); // Page engineer immediately

Expresión switch con etiquetas de flecha

Las expresiones switch con etiquetas de flecha eliminan la ejecución en cascada y la necesidad de break. Se evalúan como un valor y requieren exhaustividad.

enum Severity { LOW, MEDIUM, HIGH, CRITICAL }

Severity s = Severity.HIGH;
String action = switch (s) {
    case LOW      -> "Log and monitor";
    case MEDIUM   -> "Notify on-call team";
    case HIGH     -> "Page engineer immediately";
    case CRITICAL -> "Activate incident response";
    // no default needed — all cases covered
};
System.out.println(action); // Page engineer immediately

Expresión switch con bloques

Cuando la lógica de un caso requiere varias instrucciones, utilice un bloque con yield para producir el valor del resultado.

enum DayOfWeek { MON, TUE, WED, THU, FRI, SAT, SUN }

DayOfWeek day = DayOfWeek.FRI;
int hoursOpen = switch (day) {
    case MON, TUE, WED, THU -> 8;
    case FRI -> {
        System.out.println("Half day on Friday!");
        yield 4;  // yield returns value from block
    }
    case SAT, SUN -> 0;
};
System.out.println("Hours open: " + hoursOpen); // Hours open: 4

Agrupar varios casos

Varias constantes de enum pueden compartir el mismo caso separándolas con comas.

enum Season { SPRING, SUMMER, FALL, WINTER }

Season season = Season.SUMMER;
String activity = switch (season) {
    case SPRING, FALL -> "Hike in the mountains";
    case SUMMER       -> "Beach vacation";
    case WINTER       -> "Ski at the resort";
};
System.out.println(activity); // Beach vacation

Devolver valores desde métodos con switch

Las expresiones switch funcionan muy bien como instrucciones de retorno en los métodos, ya que dejan clara la intención.

enum Priority { LOW, NORMAL, HIGH, URGENT }

static int getSlaHours(Priority p) {
    return switch (p) {
        case LOW    -> 72;
        case NORMAL -> 24;
        case HIGH   -> 4;
        case URGENT -> 1;
    };
}

System.out.println(getSlaHours(Priority.URGENT)); // 1
System.out.println(getSlaHours(Priority.LOW));    // 72

Expresión switch en un stream

Las expresiones switch pueden utilizarse dentro de operaciones de stream para realizar transformaciones limpias elemento por elemento.

import java.util.*;
import java.util.stream.*;

enum Status { PENDING, ACTIVE, CLOSED }

record Account(String id, Status status) {}

List<Account> accounts = List.of(
    new Account("A1", Status.ACTIVE),
    new Account("A2", Status.PENDING),
    new Account("A3", Status.CLOSED)
);

accounts.stream()
    .map(a -> a.id() + ": " + switch (a.status()) {
        case ACTIVE  -> "\u2705 Live";
        case PENDING -> "\u23f3 Awaiting activation";
        case CLOSED  -> "\u274c Deactivated";
    })
    .forEach(System.out::println);

Comprobación de exhaustividad en tiempo de compilación

El compilador exige que se cubran todas las constantes del enum. Añadir una nueva constante a un enum provoca errores de compilación en todas las expresiones switch que no la gestionen.

enum Color { RED, GREEN, BLUE }  // add YELLOW here → compile error below

Color c = Color.GREEN;
// This switch is exhaustive for RED, GREEN, BLUE
// If you add YELLOW to the enum without adding a case here,
// the compiler will report an error.
String hex = switch (c) {
    case RED   -> "#FF0000";
    case GREEN -> "#00FF00";
    case BLUE  -> "#0000FF";
};
System.out.println(hex); // #00FF00

Switch con default para mayor seguridad

Al utilizar una instrucción switch (no una expresión) o cuando el switch cubre intencionadamente solo algunos casos, añada un caso default.

enum Feature { DARK_MODE, PUSH_NOTIFICATIONS, ANALYTICS, BETA_FEATURE }

static boolean isEnabled(Feature feature) {
    return switch (feature) {
        case DARK_MODE, PUSH_NOTIFICATIONS -> true;
        case ANALYTICS                     -> false;
        default -> {
            System.out.println("Unknown feature: " + feature);
            yield false;
        }
    };
}
System.out.println(isEnabled(Feature.DARK_MODE));     // true
System.out.println(isEnabled(Feature.BETA_FEATURE));  // false

Práctica: ciclo de vida de un pedido

Una máquina de estados completa para el ciclo de vida de un pedido que utiliza una expresión switch para determinar las transiciones permitidas.

enum OrderState { CART, PENDING, CONFIRMED, SHIPPED, DELIVERED, CANCELLED }

static Set<OrderState> allowedTransitions(OrderState from) {
    return switch (from) {
        case CART      -> Set.of(OrderState.PENDING, OrderState.CANCELLED);
        case PENDING   -> Set.of(OrderState.CONFIRMED, OrderState.CANCELLED);
        case CONFIRMED -> Set.of(OrderState.SHIPPED);
        case SHIPPED   -> Set.of(OrderState.DELIVERED);
        case DELIVERED, CANCELLED -> Set.of(); // terminal states
    };
}
System.out.println(allowedTransitions(OrderState.PENDING));
// [CONFIRMED, CANCELLED]

Switch sobre String frente a Enum

Usar switch sobre un String requiere comprobar si es null y distingue entre mayúsculas y minúsculas. Usarlo sobre un enum no requiere una comprobación previa de null (produce NPE si es null) y ofrece seguridad de tipos; prefiera los enums cuando el conjunto de valores sea conocido.

// String switch — fragile
String role = "admin";
String label = switch (role.toLowerCase()) {
    case "admin" -> "Administrator";
    case "guest" -> "Guest User";
    default      -> "Unknown";
};

// Enum switch — type-safe
enum Role { ADMIN, GUEST }
Role r = Role.ADMIN;
String label2 = switch (r) {
    case ADMIN -> "Administrator";
    case GUEST -> "Guest User";
};
System.out.println(label2); // Administrator

Comprobación rápida

Tiene un enum con 4 constantes y escribe una expresión switch que cubre las 4. ¿Qué ocurre si añade una quinta constante al enum?

Repaso: expresiones switch con enums

Conclusiones principales:

Las expresiones switch con etiquetas de flecha eliminan break y el comportamiento de caída al siguiente caso
Use yield para devolver un valor desde un caso con bloque
Agrupe varias constantes con comas: case A, B ->
Las expresiones switch exhaustivas no requieren default cuando se cubren todas las constantes
Añadir una nueva constante de enum provoca errores de compilación en las expresiones switch exhaustivas
Las expresiones switch son ideales en operaciones map() de stream

Preguntas frecuentes

¿La lección «Expresiones switch con enumeraciones» es gratis?

Sí — el texto completo de «Expresiones switch con enumeraciones» 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 «Expresiones switch con enumeraciones»?

Use expresiones switch modernas con enumeraciones para crear ramificaciones claras y exhaustivas. 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 3 de 4.

¿Cuánto tiempo toma la lección «Expresiones switch con enumeraciones»?

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