A minor glitch in type-safe enums

I’m quite fond of the type-safe enum design pattern. However, Wolfgang Hoscheck recently identified a place in XOM where I had introduced a bug as a result of it. Here’s an example:

public class FontStyle  {

  private int value;

  public static FontStyle PLAIN  = new FontStyle(1);
  public static FontStyle BOLD   = new FontStyle(2);
  public static FontStyle ITALIC = new FontStyle(3);
  public static FontStyle BOLD_ITALIC = new FontStyle(4);

  private FontStyle(int value) {
    this.value = value;
  }

}

The bug shows up in another class that reference the FontStyle
class:

  private FontStyle style;

  public void setStyle(FontStyle style) {
    this.style = style;
  }

Do you see the bug? The problem is that there is one thing that can be passed into setStyle that is not one of the four legal values. Can you guess what it is?

null

This makes the pattern somewhat less convenient than I thought. It’s not hugely inconvenient, but if you’re using the type-safe enum object in multiple places, then you need to check for null in each of those places. For example,

 public void setStyle(FontStyle style) {
  if (style == null) {
    throw new NullPointerException("Null style constant");
  }
  this.style = style;
}

Is there a way around this? We could certainly make null one of the legal values. However, that’s only a technical fix. Chances are if someone passes in null as a value then it’s a programmer error and should be signaled with an exception.

Do Java 5 enums fix this?I decided to find out. Here’s a simple Java 5 program that attempts to null an enum:

public class Test {

  public enum Season { WINTER, SPRING, SUMMER, FALL };
  
  public static void main(String[] args) throws Exception {

    Test t = new Test();
    t.setSeason(null);
    System.out.println(t.season);
  }

  private Season season; 
  
  private void setSeason(Season season) {
    this.season = season;
  }

}

And here’s the output:

null

Looks like Java 5 enums do not fix the problem. When you think about it, it would be hard to be otherwise. If an enum type couldn’t have a null value then code like this would also be illegal:

Season s = null;

In fact, how would you handle an uninitialized variable or field of enum type? I suppose each enum could come with a default value, but that’s not how enums are defined.

I’m afraid there’s nothing to do but remember the null checks when using enums, type-safe, Java 5, or otherwise.

This entry was posted on Saturday, January 14th, 2006 at 10:01 am and is filed under Blogroll. You can follow any responses to this entry through the Atom feed. Both comments and pings are currently closed.