Use enums to restrict arguments

Type-safe enumerations are useful for constraining arguments which must take a small set of values, such as a boolean or a restricted set of Strings or ints.

As an example from the servlet API, recall this method for the creation of an HttpSession:


Any reader who is not familiar with the specification of this method will be forced to look up the meaning of the boolean literal before they can understand the method call. An alternative style is to define a well-named variable which explains the intent:

boolean CREATE_IF_ABSENT = true;

However, the caller is not compelled to use such a style. If a type-safe enumeration is used for the argument, then the caller is indeed forced into a style which has greater clarity.


Here, CreateIfAbsent would be a static nested type-safe enumeration with two elements, YES and NO. This style has these advantages:

This style can be a bit verbose. It might be one of those rare occasions where a static import of the enum class is appropriate, to avoid using fully qualified names.

Example 1

Here's a stub class illustrating an alternate form of createSession:

import javax.servlet.http.HttpSession;

/** Clarify method call with enum argument.  */
public final class HttpRequestWithEnum {

  * Example of calling the method with an enum arg.
  public static void main(String... args){
     HttpRequestWithEnum request = new HttpRequestWithEnum();
     HttpSession session = request.createSession(CreateIfAbsent.YES);
  public HttpSession createSession(CreateIfAbsent createIfNeeded){
    return null; //stubbed out
  /** The enumeration itself.  */
  public enum CreateIfAbsent {YES, NO};
Example 2

Here's a second example that uses an enum instead of a boolean literal.

public final class LawnMower {

  enum Power{ON, OFF};

  void switchPower(Power power){
     if (Power.ON == power){ 
     else if (Power.OFF == power){


  public static void main(String... args){
    LawnMower mower = new LawnMower();
    //this is clearer than passing a boolean literal:


See Also :
Type Safe Enumerations