Question

So, I have an abstract class like:

public abstract class AbstractParent <E extends Enum<E>> {...}

Somewhere in a non-abstract method inside AbstractParent, I would like to iterate over the values of E. Is this possible?

For a better example:

public abstract class AbstractParent <E extends Enum<E>> {
    ...
    protected void doSomething() {
        //iterate over the values of E and perform an action using them
    }
}

public class Child extends AbstractParent<Child.Index> {
    public static enum Index {
        ...
    }
    public Child() {
        super();
        this.doSomething(); //this should iterate over Index's values
    }
}

EDIT:

So, thanks to mdma, this works awesomely:

public abstract class AbstractParent <E extends Enum<E>> {
    ...
    protected void doSomething() {
        //iterate over the values of E and perform an action using them
        ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass();
        Type t = pt.getActualTypeArguments()[0];
        E[] enumValues = ((Class<E>)t).getEnumConstants();
        // enumValues is now an iterable array of the values inside Index
    }
}

public class Child extends AbstractParent<Child.Index> {
    public static enum Index {
        ...
    }
    public Child() {
        super();
        this.doSomething(); //this should iterate over Index's values
    }
}

Thanks LOADS to mdma, you deserve more points than I can give.

Answer 1

EDIT2: Generics on superclasses and interfaces are not erased. You can get the generic type at runtime and use that to fetch the enum values. See Class.getGenericSuperclass. This will save you having to pass the value or a class in the constructor.

Original:
You cannot do this with generics. However, if you pass in the corresponding class also, e.g. a constructor like

AbstractParent(Class<E> enumClass)
{
   this.enumClass = enumClass;
}

Then you can use that to fetch the corresponding enum values via

public E[] getValues()
{
    return this.enumClass.getEnumConstants();
}

EDIT: Although the clients are not professional programmers, the compiler will ensure the correct class is passed. You can also make the usage clear by providing examples, and unit tests.

You could also have the constructor take and actual value of the Enum, and derive the class from that. This might be simpler to use, since the parameter is then an E rather than the more “scary” Class<E>.

E.g.

AbstractParent(E enumValue)
{
   this.enumClass = enumValue.getClass();
}