ArticleS.UncleBob.JavaEnums

Java Enums are Cool

When I first read about the new enums in Java 5, I was skeptical. These enums allow you to declare variables and methods and even abstract methods! What would you use that for? Well, I have found out the answer to at least part of that question.

While reviewing and improving a bit of code from an external source, I had the opportunity to take a set of private static final constants that represented months, and turn them into a Month enum. At first the Month enum was just a simple enum. But as I continued to improve the external code, I found more and more methods that operated on the month constants, or that were deeply associated with them. Every time I found one, I moved it to the Month enum. The result is as follows:

import java.text.DateFormatSymbols;
public enum Month {
  JANUARY(1), FEBRUARY(2), MARCH(3),
  APRIL(4),   MAY(5),      JUNE(6),
  JULY(7),    AUGUST(8),   SEPTEMBER(9),
  OCTOBER(10),NOVEMBER(11),DECEMBER(12);

  private static DateFormatSymbols dateFormatSymbols = new DateFormatSymbols();
  private static final int[] LAST_DAY_OF_MONTH =
    {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

  public int index;

  Month(int index) {
    this.index = index;
  }

  public static Month make(int monthIndex) {
    for (Month m : Month.values()) {
      if (m.index == monthIndex)
        return m;
    }
    throw new IllegalArgumentException("Invalid month index " + monthIndex);
  }

  public int lastDay() {
    return LAST_DAY_OF_MONTH[index];
  }

  public int quarter() {
    return 1 + (index - 1) / 3;
  }

  public String toString() {
    return dateFormatSymbols.getMonths()[index - 1];
  }

  public String toShortString() {
    return dateFormatSymbols.getShortMonths()[index - 1];
  }

  public static Month parse(String s) {
    s = s.trim();
    for (Month m : Month.values())
      if (m.matches(s))
        return m;

    try {
      return make(Integer.parseInt(s));
    }
    catch (NumberFormatException e) {}
    throw new IllegalArgumentException("Invalid month " + s);
  }

  private boolean matches(String s) {
    return s.equalsIgnoreCase(toString()) ||
           s.equalsIgnoreCase(toShortString());
  }
}

I find this to be quite remarkable, and very useful. I can now say things like:

Month m = Month.parse(inputString);

Month m...;
int lastDay = m.lastDay();

In java 5 enums do not define constants. They define singleton objects within a class hierarchy. There is a class named Month. There is another class representing JANUARY that derives from Month. The JANUARY class has but a single instance named JANUARY. The JANUARY enumerator is that single instance of the JANUARY class.

In effect, enums are way to create singleton classes. There will never be more than one instance of each enumerator, and the instances are created before the enumeration is used (probably at load time). And yet the enumerators are classes with the full repertoire of features that a class is allowed to have. Consider this the next time you want a singleton:

enum Database {
INSTANCE;
public void open(){...}
...
}

You could use it as follows:

Database.INSTANCE.open(...);

!commentForm -r