CODEWITHSUNDEEP
javaenums
lsoliveira
lsoliveira

Reputation: 4640

Extending Java Enums

I have a question regarding the best design pattern for code reuse when dealing with Java enums. Basically, what I'm trying to achieve is being able to define several enums that model static business collections (sets of constants), but I'd also like to share behavior between them, with minimal coding.

This is trivial to achieve with class inheritance from abstract classes but, since Java enums cannot be extended (they can only implement interfaces), this type of work is tedious and involves a lot of error prone copy/paste work (copying the code from enum to enum). Examples of "business logic" that should be shared among all enums includes converting from/to Strings, instance and logical comparison, etc.

My best shot right now is using helper classes in conjunction with business interfaces, but this only goes so far in reducing code complexity (as all enums still have to declare and invoke the helper classes). See example (just to clarify):

public enum MyEnum {
    A, B, C;

    // Just about any method fits the description - equals() is a mere example
    public boolean equals(MyEnum that) {
        ObjectUtils.equals(this, that);
    }
}

How do StackOverflowers deal with this "language feature"?

Upvotes: 5

Views: 4386

Answers (4)

Vladimir Zhilyaev
Vladimir Zhilyaev

Reputation: 175

This might look a bit ugly, but generally can offer you the required functionality.

You can have interface

public interface MyEnumInterface<T extends Enum<T>> {

    String getBusinessName();

    T getEnum();

}

Implementation

public enum OneOfMyEnums implements MyEnumInterface<OneOfMyEnums>{

    X, Y, Z;

    @Override
    public String getBusinessName() {
        return "[OneOfMyEnums]" + name();
    }

    @Override
    public OneOfMyEnums getEnum() {
        return this;
    }

}

And utility class instead of your parent class

public class MyEnumUtils {

    public static <T extends Enum<T>> String doSomething(MyEnumInterface<T> e){
        e.getBusinessName(); // can use MyEnumInterface methods
        e.getEnum().name(); // can use Enum methods as well
        return null;
    }

}

Upvotes: 0

Itay Maman
Itay Maman

Reputation: 30723

You can move the reusable logic to dedicated (non-enum) classes and then have the enums delegate to those classes. Here's an example:

[Side note: the inheritance of PlusTwo extends PlusOne is not recommended (b/c PlusTwo is not PlusOne). It here just to illustrate the point of being able to extend an existing logic.]

public interface Logic {
  public int calc(int n);
}

public static class PlusOne implements Logic {
  public int calc(int n) { return n + 1; }
}

public static class PlusTwo extends PlusOne {
  @Override
  public int calc(int n) { return super.calc(n) + 1; }
}

public static enum X {
  X1, X2;   
  public Logic logic;

  public int doSomething() { 
    return logic.calc(10);
  }
}

public static enum Y {
  Y1, Y2;
  public Logic logic;

  public String doSomethingElse() { 
    return "Your result is '" + logic.calc(10) + "'";
  }
}

public static void main(String[] args) {
  // One time setup of your logic:
  X.X1.logic = new PlusOne();
  X.X2.logic = new PlusTwo();  
  Y.Y1.logic = new PlusOne();
  Y.Y2.logic = new PlusTwo();

  System.out.println(X.X1.doSomething());
  System.out.println(X.X2.doSomething());
  System.out.println(Y.Y1.doSomethingElse());
  System.out.println(Y.Y2.doSomethingElse());
}

Upvotes: 3

Garrett Hall
Garrett Hall

Reputation: 30022

I rarely find enums useful, except for representing finite states in which case they do not need behavior.

I would suggest refactoring enums that need behavior into classes with a Factory.

Upvotes: 2

Peter Lawrey
Peter Lawrey

Reputation: 533492

I would do the same, or combine the Enums into a super-enum.

With Java 8 this will be easier. You will be able to define a default implementation for interface methods and have the enum extend the interface.

Upvotes: 2

Related Questions