Question

Please see
Java Enum definition
and
Why in java enum is declared as Enum<E extends Enum<E>>
for general discussion. Here I would like to learn what exactly would be broken (not typesafe anymore, or requiring additional casts etc) if Enum class was defined as

public class Enum<E extends Enum> 

I’m using this code for testing my ideas:

interface MyComparable<T> {
    int myCompare(T o);
}

class MyEnum<E extends MyEnum> implements MyComparable<E> {
    public int myCompare(E o) { return -1; }
}

class FirstEnum extends MyEnum<FirstEnum> {}

class SecondEnum extends MyEnum<SecondEnum> {}

With it I wasn’t able to find any benefits in this exact case.

PS. the fact that I’m not allowed to do

class ThirdEnum extends MyEnum<SecondEnum> {}

when MyEnum is defined with recursion is
a) not relevant, because with real enums you are not allowed to do that just because you can’t extend enum yourself
b) not true – pls try it in a compiler and see that it in fact is able to compile w/o any errors

PPS. I’m more and more inclined to believe that the correct answer here would be “nothing would change if you remove the recursive part” – but I just can’t believe that.

Answer 1

I believe that a compelling reason to do that is that it makes the code in the MyEnum class more typesafe.

Consider that the recursive part makes such a thing possible:

class MyEnum<E extends MyEnum<E>> {
    private Thing<E> util1() { return someObject }
    private void util2(E e) {}
    public int method(E o) { 
        Thing<E> thingy = o.util1(); 
        // You can call the util1 method on o and get a type safe return element.
        E o1 = // I don't care how you get a parametrized E object.
        o.util2(o1);
        // You can call the util2 method with a typesafe parameter.
    }
}

In short, that recursivity lets you put typesafe methods in the Enum class that you can call on any E element, and these calls will be typesafe.