Enum type class hierarchy.

Question

Hi,
I was reviewing and eagerly testing the Typesafe Enum Facility (enum types) on 1.5.0 beta, which is still in Public Review in the JCP (JSR-201).
I would would like to mention a missing feature that I find usefull and powerfull for a custom framework architecture.
I understand and agree with respect to the first question on the JSR 201 FAQ, about subclassing enums.
Having enumeration constants from both the superclass and the subclass is quite confusing and I agree with disallowing it from the language.
But I miss the ability to inherit custom behavior (methods, and not enumeration constants), for an enum type, from a middle superclass. This middle superclass could be a base class for enum types within a specific development framework (and of course, java.lang.Enum would by in is class hierachy).
The actual proposal allows for an enum type to only have java.lang.Enum as superclass, from which it inherits methods like name() and ordinal(). But in a proyect where a large number of diferent enum types with a common and custom extra framework behavior (like a localizedName() or propertyKey() method for example) would need the implementation of this behavior in each enum type source code (or in a helper class).
Following the example above, the actual proposal would need the following coding in order to add an additional behavior to all (or some) of the enum types in a development proyect:
public interface MyBaseFrameworkEnum {
     String localizedName();
     String propertyKey();
public enum FooEnum implements MyBaseFrameworkEnum {
     FOO_A, FOO_B;
     public String localizedName() {
          //..... coding necesary in every enum implementing BaseFrameworkEnum
     public String propertyKey() {
          //..... coding necesary in every enum implementing BaseFrameworkEnum
As you see, every enum type in my example framework (like FooEnum) would need to code both methods localizedName() and propertyKey() which would produce a lack of centralized code and increase of class file size.
It would be very powerfull to be able to use the following coding:
public abstract enum MyBaseFrameworkEnum {
     public String localizedName() {
          //..... coding centralized
     public String propertyKey() {
          //..... coding centralized
public enum FooEnum extends MyBaseFrameworkEnum {
     FOO_A, FOO_B;
As you see, with this abstract enum MyBaseFrameworkEnum (which does not falls in the subclassing problem mentioned in the FAQ) does not define enum constants and will pass its custom behavior to its subclass enums. thus centralizing the related code.
I generally use an implementation of the Typesafe Enum Pattern so I really am looking forward for this new Typesafe Enum Facility in the Java language. But, as an example, I generally use common features in my enums, a properyKey() method used to get a unique key in order to internationalize my applications, since a description to enums is normally needed to be displayed to users.
I believe this capability would be very powerfull in cases where common features are needed for enums in a development proyect with respect of:
- code centralization and maintainance.
- class file size.
- source code readability.
This extension would not contradict the actual definition, it would only allow for an enum type to be able to extend from another abstract enum type which has no enumeration constants.
I believe that if there are other programmers that find this extension worth, it could make it in the JSR-201(which is in public review until February 21th) process before the final specification.
Regards,
Luis Longeri

Answer 1

It would be very powerfull to be able to use the
following coding:
public abstract enum MyBaseFrameworkEnum {
     public String localizedName() {
          //..... coding centralized
     public String propertyKey() {
          //..... coding centralized
public enum FooEnum extends MyBaseFrameworkEnum {
     FOO_A, FOO_B;
}Luis, I like your idea but don't really like the idea of an abstract enum. I think this would be better
public class MyBaseFrameworkEnum extends Enum {
     public String localizedName() {
          //..... coding centralized
     public String propertyKey() {
          //..... coding centralized
public enum FooEnum extends MyBaseFrameworkEnum {
     FOO_A, FOO_B;
}However, this always opens up the risk of you breaking the enum specific stuff, so all the vulnerable Enum methods would need to be declared "final".
Because you are unlikely to see this in the language any time soon (if at all), you can always centralise your code in some static methods that take the enum as an argument
public class MyBaseFrameworkEnumTools {
     public String localizedName(Enum e) {
          //..... coding centralized
     public String propertyKey(Enum e) {
          //..... coding centralized