Use Enum.values in with generic class extending Enum

Question

I am trying to initialise a generic class with all the availables values from an Enum. HEre is how I would like it to work:

public class MyClass<E extends Enum<E>> {

    E[] choices;

    public MyClass() {
        choices = E.values();
    }

However, the call to E.values is not accepted in Eclipse saying that this method is undefined for this E.

Using this constructor instead is accepted, but requires the caller to provide the values:

public MyClass(E[] e) {
    choices = e;
}

In the documentation I found:

Java programming language enum types are much more powerful than their counterparts in other languages. The enum declaration defines a class (called an enum type). The enum class body can include methods and other fields. The compiler automatically adds some special methods when it creates an enum. For example, they have a static values method that returns an array containing all of the values of the enum in the order they are declared.

Is there a way to workaround this issue ?

score 22 · Accepted Answer · answered Jul 26 '12 at 06:52

22

Your best option is probably to pass a Class of the desired enum to the constructor. (See how an EnumMap is constructed for instance.)

You can then use clazz.getEnumConstants() to get hold of the constants.

answered Jul 26 '12 at 06:52

aioobe

413,195
112
811
826

score 3 · Answer 2 · edited May 23 '17 at 12:17

3

Your first code snippet doesn't work because of how Generics is implemented in Java, and due to a phenomenon known as type erasure. Because of this, the JVM will have no idea what the type of E is when your program is executing.

You could probably do something like this in MyClass's constructor:

public MyClass(E type) {
    choices = type.getDeclaringClass().getEnumConstants();
}

edited May 23 '17 at 12:17

Community

1
1

answered Jul 26 '12 at 06:58

Jeshurun

22,940
6
79
92

I believe this has nothing to do with type erasure. The cause of the problem is that the method `public static E[] values()` is not a method present in the `java.lang.Enum` class. [The Java Language Specification](http://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html#jls-8.9.2) explains that this method, though, is synthetically generated for all enums. So, in my opinion, the method is present in any concrete reference of a enum, but not in the enum class itself. – Edwin Dalorzo Jul 26 '12 at 07:28
If you have two classes, `public class A { public static void test(){} }` and `public class B { public B() {A.test();} }`, the line A.test() is still a compile time error, because at runtime, the compiler would not know the type of A without it being explicitly defined, say as a parameter of type A passed into the constructor. – Jeshurun Jul 26 '12 at 07:44
1

@Jeshrun No it's not. It's a compile-time error because in your declaration `class B` the `A` is an unbounded type argument. The `A` in this declaration has nothing to do with the class `A`. Would it compile if you declare it as `class B` where the declaration has no obvious ambiguities between the type parameter and the class name and by using a reference to T? – Edwin Dalorzo Jul 26 '12 at 07:56
@Jeshrun I am not arguing with the fact that you cannot directly access members of a type parameter `T`. But you could acccess them through a valid reference of type `T` if you had one. Which proves your type erasure theory as bogus in my opinion. – Edwin Dalorzo Jul 26 '12 at 08:02
@Jeshrun Bottom line, in the question `E` is a type parameter, not a class; and as you well pointed out the reason why we cannot directly access `E` is because the type information related to it is discarded. But you could perfectly invoke static methods in refrences of `E`. In the question we could invoke `choices.valueOf(...)` which is a static method of the class `Enum`. However, the reason why we cannot invoke `choices.values()` it's because it does not exist in the `Enum` class. It is however synthetically generated for every concrete enum by the compiler. – Edwin Dalorzo Jul 26 '12 at 08:14
Ok you are saying it is bogus in one comment, and that you agree with it in the next. But I still disagree with the invoking static methods on a generic type. Even if the generic type is a derived type with the parent type containing static methods, the vm would still have no clue what the type of the parent is at runtime, unless there is a reference of said type lying around. – Jeshurun Jul 26 '12 at 08:39

Use Enum.values in with generic class extending Enum

2 Answers2