Un enum define un tipo con un conjunto fijo de constantes nombradas. Los enums de Java son mucho más poderosos que las listas simples de constantes en otros lenguajes — son clases completas que pueden tener campos, constructores y métodos.
{
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
Day.MONDAY;
(today) {
MONDAY -> System.out.println();
SATURDAY, SUNDAY -> System.out.println();
-> System.out.println();
}
Los enums proporcionan seguridad de tipos — Day today = Day.MONDAY solo puede contener valores válidos de Day, a diferencia de usar números enteros o cadenas arbitrarios como constantes (que permiten valores inválidos y errores tipográficos).
Day.MONDAY.name(); // "MONDAY"
Day.MONDAY.ordinal(); // 0 — position in the declaration
Day.values(); // array of all constants (iterate them)
Day.valueOf("FRIDAY"); // get a constant by name
for (Day d : Day.values()) { ... } // iterate all values
public enum Planet {
MERCURY(3.3e23, 2.4e6), // each constant calls the constructor with arguments
EARTH(5.97e24, 6.37e6),
JUPITER(1.9e27, 7.1e7);
private final double mass; // enums can have FIELDS
private final double radius;
Planet(double mass, double radius) { // constructor (implicitly private)
this.mass = mass;
this.radius = radius;
}
public double surfaceGravity() { // and METHODS
return 6.67e-11 * mass / (radius * radius);
}
}
Planet.EARTH.surfaceGravity(); // compute using EARTH's data
Cada constante de enum es una instancia, configurada a través del constructor — permitiéndote asociar datos y comportamiento con cada constante. Esto es único y poderoso en comparación con los enums de la mayoría de lenguajes.
public enum Operation {
PLUS { 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); // each constant implements it differently
}
Operation.PLUS.apply(2, 3); // 5
public enum Config { INSTANCE; /* fields/methods */ }
// enum singletons are thread-safe and serialization-safe by design
Los enums de Java son una forma robusta y segura de tipos para representar conjuntos fijos de constantes relacionadas (estados, días, roles, operaciones) — muy superior a la alternativa propensa a errores de constantes int/String, que permite valores inválidos y no ofrece comprobación de tipos.
Su poder único — campos, constructores, métodos, implementación de interfaces y comportamiento por constante — te permite asociar datos y lógica con cada constante, modelando conceptos de dominio elegantemente (p. ej. planetas con masa/gravedad, operaciones con su matemática).
También proporcionan el patrón singleton más seguro.
Comprender los enums más allá de listas simples de constantes — como clases completas con estado y comportamiento — permite un modelado de dominio más limpio y seguro y es una característica de Java frecuentemente subutilizada pero valiosa, así como un tema común en entrevistas.