Enums en Java: un conjunto fijo de constantes con nombre

Un conjunto fijo de valores con nombre

Algunos valores solo tienen sentido como uno de una lista pequeña y conocida: los días de la semana, los palos de una baraja, los estados en los que puede estar un pedido. Podrías modelarlos con códigos int (0 para pendiente, 1 para enviado) o con cadenas ("PENDING", "SHIPPED"), pero nada impide que quien llama pase 7 o "PNEDING". Un enum cierra ese agujero: el propio tipo solo admite los valores que has declarado.

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

public class Main {
    public static void main(String[] args) {
        Day today = Day.WEDNESDAY;
        System.out.println(today);          // WEDNESDAY
        System.out.println(today == Day.WEDNESDAY);
    }
}

Day es un tipo completamente nuevo. Una variable de tipo Day puede contener exactamente una de esas siete constantes (o null) y nada más. El compilador rechaza Day d = "WEDNESDAY"; o Day d = 2;. Esa garantía es justo el objetivo.

Cada constante (Day.MONDAY, etc.) es una única instancia compartida, creada una sola vez. Como solo existe un MONDAY, comparas enums con == en lugar de equals: son el mismo objeto.

Usar switch sobre un enum

Los enums encajan de forma natural con switch. Ni siquiera necesitas cualificar cada constante con el nombre del tipo dentro del switch:

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

public class Main {
    static String kind(Day d) {
        switch (d) {
            case SATURDAY:
            case SUNDAY:
                return "weekend";
            default:
                return "weekday";
        }
    }

    public static void main(String[] args) {
        System.out.println(kind(Day.SATURDAY));
        System.out.println(kind(Day.MONDAY));
    }
}

Dentro del switch, escribe case SATURDAY, no case Day.SATURDAY: Java infiere el tipo. La gran ventaja frente a usar switch sobre una cadena o un int es que si añades una nueva constante más adelante, tu IDE y las comprobaciones de exhaustividad pueden señalar cada switch que se olvidó de gestionarla.

Recorrer todas las constantes

Cada enum obtiene automáticamente un método estático values() que devuelve todas sus constantes en el orden de declaración, además de un ordinal() que da la posición de cada constante empezando en cero:

enum Suit { HEARTS, DIAMONDS, CLUBS, SPADES }

public class Main {
    public static void main(String[] args) {
        for (Suit s : Suit.values()) {
            System.out.println(s.ordinal() + " -> " + s.name());
        }
    }
}

name() da el identificador de la constante como un String, y values() es perfecto para construir menús o iterar sobre opciones. Una advertencia: no guardes el ordinal() en ningún sitio persistente. Si alguien reordena las constantes más adelante, los números cambian y tus datos guardados se rompen. Trata ordinal() como un detalle de implementación, no como un identificador estable.

Los enums son clases de verdad: campos y métodos

Aquí es donde los enums de Java van más allá de los enums de enteros con nombre de otros lenguajes. Cada constante puede llevar datos, pasados a través de un constructor, y el enum puede tener métodos. Primero enumeras las constantes, le das a cada una sus argumentos de constructor, y luego declaras los campos, el constructor y los métodos después de un punto y coma.

enum Planet {
    MERCURY(3.303e23, 2.4397e6),
    EARTH(5.976e24, 6.37814e6);

    private final double mass;     // kilogramos
    private final double radius;   // metros

    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }

    double surfaceGravity() {
        final double G = 6.67300e-11;
        return G * mass / (radius * radius);
    }
}

public class Main {
    public static void main(String[] args) {
        for (Planet p : Planet.values()) {
            System.out.printf("%s gravity: %.2f%n", p, p.surfaceGravity());
        }
    }
}

Fíjate en la estructura: las constantes van primero y terminan con un punto y coma, y luego sigue el resto de la clase. El constructor es implícitamente private: nunca puedes escribir new Planet(...), porque las únicas instancias permitidas son las declaradas arriba. Los campos final hacen que cada constante sea inmutable, que es exactamente lo que quieres para singletons compartidos.

De una cadena y vuelta

Para convertir una cadena en la constante correspondiente, usa el valueOf autogenerado:

enum Status { PENDING, SHIPPED, DELIVERED }

public class Main {
    public static void main(String[] args) {
        Status s = Status.valueOf("SHIPPED");
        System.out.println(s == Status.SHIPPED);   // true

        try {
            Status bad = Status.valueOf("shipped"); // ¡distingue mayúsculas y minúsculas!
            System.out.println(bad);
        } catch (IllegalArgumentException e) {
            System.out.println("no constant named 'shipped'");
        }
    }
}

valueOf busca el nombre de la constante de forma exacta, incluyendo mayúsculas y minúsculas, y lanza IllegalArgumentException si no hay coincidencia. Ese es el error habitual: "shipped" no coincide con SHIPPED. Cuando proceses entrada de usuario o datos externos, normaliza primero las mayúsculas (input.toUpperCase()) y envuelve la llamada en un try/catch, o reventará con el primer valor incorrecto.

Comportamiento por constante

A veces cada constante necesita comportarse de forma distinta, no solo guardar datos distintos. Puedes darle a un enum un método abstracto y hacer que cada constante aporte su propia implementación en un pequeño cuerpo:

enum Operation {
    PLUS  { public int apply(int a, int b) { return a + b; } },
    MINUS { public int apply(int a, int b) { return a - b; } },
    TIMES { public int apply(int a, int b) { return a * b; } };

    public abstract int apply(int a, int b);
}

public class Main {
    public static void main(String[] args) {
        for (Operation op : Operation.values()) {
            System.out.println(op + ": " + op.apply(6, 2));
        }
    }
}

A esto se le llama a veces el patrón de "método específico de constante". Sustituye un switch enorme sobre la constante por comportamiento adjunto directamente a cada una: añade una nueva operación y el compilador te obliga a definir su apply, así que no puedes olvidarte de ningún caso.

Cuándo recurrir a un enum

Usa un enum siempre que un valor sea, de forma natural, uno de un conjunto pequeño, fijo y conocido en tiempo de compilación:

• Estados de un flujo de trabajo (PENDING, SHIPPED, DELIVERED).
• Categorías, modos o tipos (READ, WRITE, EXECUTE).
• Cualquier lugar donde te tentara definir un grupo de constantes public static final int: el enum te da los mismos valores con nombre más seguridad de tipos, un toString legible y soporte de switch gratis.

No uses un enum para un conjunto abierto o determinado en tiempo de ejecución (nombres de usuario, una lista de países obtenida de una base de datos). Los enums se fijan en tiempo de compilación; si el conjunto cambia mientras el programa se ejecuta, lo que quieres es una colección normal.

Siguiente: Genéricos

Ya has visto values() devolviendo un Planet[] y, en páginas anteriores, el uso de List<Shape>: esa sintaxis <...> son los genéricos, la forma que tiene Java de escribir una clase o método que funciona para muchos tipos manteniendo plena seguridad de tipos. A continuación analizaremos cómo funcionan realmente List<String> y Map<K, V> y cómo escribir tus propios tipos genéricos.