Understanding Enums in Java

by

Enums in Java 5+ are basically classes that have a predefined set of instances. They are intended as a replacement for, say, a collection of integer constants. They are preferably to constants as they can enforce type safety.

So instead of:

public class Suit {
  public final static int SPADES = 1;
  public final static int CLUBS = 2
  public final static int HEARTS = 3;
  public final static int DIAMONDS = 4;
}

you have:

public enum Suit {
  SPADES, CLUBS, HEARTS, DIAMONDS
}

The advantages are:

  1. Type safety. You can declare a function argument, return type, class member or local variable to be a particular Enum type and the compiler will enforce type safety;
  2. Enums are basically classes. They can implement interfaces, have behaviour and so on.

The type safety is an issue because in the first example, these are valid statements:

int i = Suit.DIAMONDS * Suit.CLUBS;

or you can pass in 11 to a function expecting a suit. You can’t do that with a typesafe enum.

You can use a class for Suit to provide type safety and this was the solution before Java 5. Josh Bloch (in Effective Java, which is a must read for Java programmers imho) promoted the typesafe enum pattern that became the Java 5+ enum. It has a fair amount of boilerplate on it and some corner cases that people didn’t tend to cater for, such as serialization not calling a constructor and to ensure you only got one instance you had to override the readResolve() method.

For example:

public enum CardColour {
  RED, BLACK
}

public enum Suit {
  SPADES(CardColour.BLACK),
  CLUBS(CardColour.BLACK),
  HEARTS(CardColour.RED),
  DIAMONDS(CardColour.RED);

  private final CardColour colour;

  Suit(CardColour colour) { this.colour = colour; }

  public CardColour getColour() { return colour; }
}

Edit: Sun has an introduction to typesafe enums.

As for interfaces, they really complement enums rather than being an alternative. Like you could say that Suit is an interface and you’d have this:

public interface Suit {
  CardColour getColour();
}

The problem is that you could go and define 300 different suits and you could also define Spades several times. Another advantage of enums is (classloading corner cases notwithstanding) is that there is only one instance of each enum value. Typically this is referred to as having a canonical value, meaning this equality holds true:

a.equals(b) == b.equals(a) == (a == b)

for all a, b that are instances of a particular Enum. This means that instead of writing:

if (card.getSuit().equals(Suit.SPADES)) { ... }

you can write:

if (card.getSuit() == Suit.SPADES) { ... }

which is quicker and typically easier to read. Plus IDEs will typically give you feedback if you’re comparing enums of different types saying they can’t possibly be equal, which can be a useful and early form of error-checking.

More Related Contents:

  1. How to get an enum value from a string value in Java
  2. How do I use Comparator to define a custom sort order?
  3. Java Enum definition
  4. Map enum in JPA with fixed values?
  5. How can I lookup a Java enum from its String value?
  6. In Java, are enum types inside a class static?
  7. Jackson enum Serializing and DeSerializer
  8. Coding Conventions – Naming Enums
  9. Convert from enum ordinal to enum type
  10. Java enum and additional class files
  11. A for-loop to iterate over an enum in Java
  12. Enum in Java. Advantages?
  13. Getting enum associated with int value
  14. What’s the best way to implement `next` and `previous` on an enum type?
  15. Ways to save enums in database
  16. Why shouldn’t Java enum literals be able to have generic type parameters?
  17. Conveniently map between enum and int / String
  18. How to convert enum value to int?
  19. Use Enum type as a value parameter for @RolesAllowed-Annotation
  20. Enum in Hibernate, persisting as an enum
  21. Iterate enum values using java generics
  22. Enumerations: Why? When?
  23. Switch over type in java
  24. Java Enums and Switch Statements – the default case?
  25. Lambdas in the classical Operation enum example
  26. Java: Check if enum contains a given string?
  27. Using nested enum types in Java
  28. Can not compile enums in Eclipse
  29. How to enable enum inheritance
  30. Why Java does not allow overriding equals(Object) in an Enum?

Leave a Comment