Enums con campos y métodos
Añada comportamiento a los enums
Enums con campos y métodos es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 1 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.
Los enum son clases completas
Un enum de Java es mucho más que una lista de constantes. Es una clase real cuyas instancias son las constantes.
Esto significa que los enum pueden tener campos, constructores y métodos, como cualquier otra clase.
public class Main {
enum Direction { NORTH, SOUTH, EAST, WEST }
public static void main(String[] args) {
Direction d = Direction.NORTH;
System.out.println(d + " is a " + d.getClass().getSuperclass().getSimpleName());
}
}Añadir un campo
Puede asociar datos a cada constante. Declare un campo final y un constructor; después, pase los valores entre paréntesis después de cada constante.
public class Main {
enum Planet {
EARTH(9.81), MARS(3.71), JUPITER(24.79);
private final double gravity;
Planet(double gravity) { this.gravity = gravity; }
double gravity() { return gravity; }
}
public static void main(String[] args) {
System.out.println("Mars gravity: " + Planet.MARS.gravity());
}
}El constructor de un enum es privado
Los constructores de un enum son implícitamente private. No puede usar new con un enum; la JVM crea las constantes una sola vez al cargar la clase.
Esto garantiza un conjunto fijo y finito de instancias.
public class Main {
enum Coin {
PENNY(1), NICKEL(5), DIME(10), QUARTER(25);
private final int cents;
Coin(int cents) { this.cents = cents; }
int cents() { return cents; }
}
public static void main(String[] args) {
int total = Coin.QUARTER.cents() + Coin.DIME.cents();
System.out.println("Total cents: " + total);
}
}Varios campos
Una constante puede contener varios datos. Aquí cada planeta almacena tanto la masa como el radio.
public class Main {
enum Planet {
EARTH(5.976e24, 6.37814e6),
MARS(6.421e23, 3.3972e6);
private final double mass, radius;
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 static void main(String[] args) {
System.out.printf("Earth g = %.2f%n", Planet.EARTH.surfaceGravity());
}
}Métodos de instancia
Los métodos de un enum pueden calcular resultados a partir de los propios campos de la constante, igual que los métodos de instancia normales.
public class Main {
enum Size {
SMALL(8), MEDIUM(12), LARGE(16);
private final int ounces;
Size(int ounces) { this.ounces = ounces; }
int ounces() { return ounces; }
double liters() { return ounces * 0.0295735; }
}
public static void main(String[] args) {
System.out.printf("Large = %.2f L%n", Size.LARGE.liters());
}
}name() y ordinal() integrados
Cada enumeración incluye name() (el identificador exacto) y ordinal() (su posición basada en cero).
Es preferible almacenar sus propios datos en lugar de depender de ordinal(), ya que deja de ser fiable si cambia el orden de las constantes.
public class Main {
enum Day { MON, TUE, WED }
public static void main(String[] args) {
for (Day d : Day.values()) {
System.out.println(d.name() + " -> ordinal " + d.ordinal());
}
}
}values y valueOf
El compilador genera dos métodos auxiliares estáticos:
values()devuelve un arreglo con todas las constantes.valueOf(String)busca una constante por nombre y lanza una excepción si no la encuentra.
public class Main {
enum Status { ACTIVE, PAUSED, CLOSED }
public static void main(String[] args) {
System.out.println("count: " + Status.values().length);
Status s = Status.valueOf("PAUSED");
System.out.println("parsed: " + s);
}
}Sobrescribir toString
Puede sobrescribir toString() para proporcionar etiquetas más claras, conservando el nombre de la constante para el código.
public class Main {
enum Priority {
LOW, MEDIUM, HIGH;
@Override public String toString() {
return name().charAt(0) + name().substring(1).toLowerCase();
}
}
public static void main(String[] args) {
for (Priority p : Priority.values()) System.out.println(p);
}
}Enumeraciones en switch
Las enumeraciones funcionan de forma muy clara en switch. Con las expresiones switch modernas, obtiene comprobaciones de exhaustividad y evita el efecto de caída entre casos.
public class Main {
enum Traffic { RED, YELLOW, GREEN }
static String action(Traffic t) {
return switch (t) {
case RED -> "Stop";
case YELLOW -> "Slow down";
case GREEN -> "Go";
};
}
public static void main(String[] args) {
System.out.println(action(Traffic.GREEN));
}
}Mapas de búsqueda estáticos
Un patrón habitual consiste en crear un mapa estático que asocie un campo con su constante, inicializado una sola vez en un inicializador estático.
import java.util.HashMap;
import java.util.Map;
public class Main {
enum Op {
PLUS("+"), MINUS("-");
private final String symbol;
Op(String symbol) { this.symbol = symbol; }
private static final Map<String, Op> BY_SYMBOL = new HashMap<>();
static { for (Op o : values()) BY_SYMBOL.put(o.symbol, o); }
static Op fromSymbol(String s) { return BY_SYMBOL.get(s); }
}
public static void main(String[] args) {
System.out.println(Op.fromSymbol("-"));
}
}Las enumeraciones implementan interfaces
Una enumeración puede implementar una interfaz, lo que permite que sus constantes se integren en código de propósito general.
public class Main {
interface Describable { String describe(); }
enum Animal implements Describable {
DOG, CAT;
public String describe() { return "A " + name().toLowerCase(); }
}
public static void main(String[] args) {
Describable d = Animal.DOG;
System.out.println(d.describe());
}
}Comprobación rápida
Compruebe cuánto entiende sobre los campos de las enumeraciones.
Repaso
Ha aprendido que las enumeraciones son clases completas:
- Las constantes pueden contener campos establecidos mediante un constructor privado.
- Las enumeraciones pueden tener métodos de instancia y sobrescribir
toString(). values()yvalueOf()se generan automáticamente.- Las enumeraciones pueden implementar interfaces; además, es preferible usar campos en lugar de
ordinal().
A continuación, comportamiento por constante con métodos abstractos.
public class Main {
enum Greeting { HELLO; String text() { return "Hi"; } }
public static void main(String[] args) {
System.out.println("Enum fields recap: " + Greeting.HELLO.text());
}
}Preguntas frecuentes
¿La lección «Enums con campos y métodos» es gratis?
Sí — el texto completo de «Enums con campos y métodos» 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 «Enums con campos y métodos»?
Añada comportamiento a los enums 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 1 de 4.
¿Cuánto tiempo toma la lección «Enums con campos y métodos»?
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
- Enums con campos y métodos
- Métodos abstractos en enums
- EnumSet
- EnumMap