Java Enums in Depth

An enum is a fixed set of named constants, and each constant can carry its own data. A constructor sets that data when the constant is made.

Constants carry a field

Each level carries a points value. The constructor sets it once per constant.

public class Main {
  public static void main(String[] args) {
    System.out.println(Level.LOW.points());
    System.out.println(Level.HIGH.points());
  }
}
enum Level {
  LOW(5),
  MEDIUM(10),
  HIGH(20);
  private final int points;
  Level(int points) {
    this.points = points;
  }
  int points() {
    return points;
  }
}

Values walk in declaration order

The values method answers every constant. The order matches the declaration.

public class Main {
  public static void main(String[] args) {
    for (Level level : Level.values()) {
      System.out.println(level);
    }
  }
}
enum Level {
  LOW(5),
  MEDIUM(10),
  HIGH(20);
  private final int points;
  Level(int points) {
    this.points = points;
  }
  int points() {
    return points;
  }
}

ValueOf finds a constant by name

The name text HIGH finds its constant. Its points value prints next.

public class Main {
  public static void main(String[] args) {
    Level level = Level.valueOf("HIGH");
    System.out.println(level);
    System.out.println(level.points());
  }
}
enum Level {
  LOW(5),
  MEDIUM(10),
  HIGH(20);
  private final int points;
  Level(int points) {
    this.points = points;
  }
  int points() {
    return points;
  }
}

Name and ordinal describe a constant

Name answers the constant text. Ordinal answers its position in the declaration.

public class Main {
  public static void main(String[] args) {
    Level level = Level.MEDIUM;
    System.out.println(level.name());
    System.out.println(level.ordinal());
    System.out.println(level.points());
  }
}
enum Level {
  LOW(5),
  MEDIUM(10),
  HIGH(20);
  private final int points;
  Level(int points) {
    this.points = points;
  }
  int points() {
    return points;
  }
}

Example

public class Main {
  public static void main(String[] args) {
    for (Level level : Level.values()) {
      System.out.println(level.name() + " gives " + level.points() + " points.");
    }
  }
}
enum Level {
  LOW(5),
  MEDIUM(10),
  HIGH(20);
  private final int points;
  Level(int points) {
    this.points = points;
  }
  int points() {
    return points;
  }
}

Key points

Each enum constant carries a field set by an enum constructor.
The values method walks all constants in declaration order.
The valueOf method finds a constant by its name text.
The name method answers the constant name text.
The ordinal method answers the constant position, starting at zero.

In this example, values walks every constant in order, and each line pairs its name with its carried points value.

Note

Ordinal is a position, not data, so code should not store it as meaning.

Try it Yourself

Edit the code, then press Run.

Running is simulated

public class Main {
  public static void main(String[] args) {
    for (Level level : Level.values()) {
      System.out.println(level.name() + " gives " + level.points() + " points.");
    }
  }
}
enum Level {
  LOW(5),
  MEDIUM(10),
  HIGH(20);
  private final int points;
  Level(int points) {
    this.points = points;
  }
  int points() {
    return points;
  }
}

Exercise

Level has constants LOW, MEDIUM and HIGH in that order. What does Level.MEDIUM.ordinal() answer?

LOW 0 2 1