What would be different in Java if Enum declaration didn't have the recursive part

Question

Please see http://stackoverflow.com/questions/211143/java-enum-definition and http://stackoverflow.com/questions/3061759/why-in-java-enum-is-declared-as-enume-extends-enume 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

Consider Enum<E>.compareTo(E other).

That:

• Needs to work with E rather than enum so that you don't try to compare one enum value with a value from a different enum
• Needs to be able to get the ordinal value of the enum, via the ordinal() method declared on Enum.

How would you propose making that work without the current constraint?

That's just the first one I came up with... I'm sure there are plenty of others. Basically it's a way of saying, "You shouldn't try to treat all enums as equivalent to each other... an enum is a closed set in itself, but all enums share certain properties."

Answer 2

Well, first of all it would complain about using the raw type, but you could do:

public class Enum<E extends Enum<?>>

for the same effect.

Also, with this type of generic you could do something like:

class FirstEnum extends MyEnum<SecondEnum> {
}

class SecondEnum extends MyEnum<FirstEnum> {
}

which to me seems like it could lead to a lot of trouble. More exactly you can't compare an enum of type FirstEnum with an enum of the same type, you have to compare it with an enum of the other type, which is really troublesome if you have a List<FirstEnum> that you want sorted. The example will not compile if i set E instead o ? since SecondEnum is not of the type E extends MyEnum<E> (this would lead to circular inheritance). It will work if FirstEnum extends MyEnum<FirstEnum> though (which would mean that SecondEnum is a child class of FirstEnum - normal hierarchical inheritance).

Answer 3

If you didn't have the generic type parameter, then you wouldn't be able to extend Comparable<T extends Comparable> for the specific subtype of enum you have created.

You could ignore this, and create your own MyEnum type which behaves much the same but without the restriction that different MyEnum are not comparable:

public abstract class MyEnum implements Comparable<MyEnum>
{
    private final int ordinal;

    protected MyEnum ( int ordinal )
    {
        this.ordinal = ordinal;
    }

    public int ordinal ()
    {
        return ordinal ;
    }

    public int compareTo ( MyEnum other )
    {
        return ordinal - other.ordinal; // ignore overflow for now
    }

    public boolean equals (Object other) {
        return ordinal == ((MyEnum)other).ordinal;
    }

    public int hashCode () {
        return ordinal;
    }
}

This behaves in much the same way as an enum would for the operations defined, but instead of being a generic type safe implementation obeys LSP - objects of different subclasses of MyEnum are comparable or equal to each other if they have the same ordinal value.

public static class EnumA extends MyEnum
{
    private EnumA ( int ordinal ) { super ( ordinal ); }
    public static final EnumA a = new EnumA ( 0 );
    public static final EnumA b = new EnumA ( 1 );
}

public static class EnumB extends MyEnum
{
    private EnumB ( int ordinal ) { super ( ordinal ); }
    public static final EnumB x = new EnumB ( 0 );
    public static final EnumB y = new EnumB ( 1 );
}

public static void main ( String...args )
{
    System.out.println ( EnumA.a.compareTo ( EnumB.x ) );
    System.out.println ( EnumA.a.equals ( EnumB.x ) );
    System.out.println ( EnumA.a.compareTo ( EnumB.y ) );
    System.out.println ( EnumA.a.equals ( EnumB.y ) );
}

In this case, if you don't override equals, you lose the convention that x.comparesTo(y)=0 implies x.equals(y); if you do override equals then there are cases where x.equals(y) does not imply x == y (as for other value objects), whereas for Java enums both tests of equality produce the same result.

Answer 4

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.

Answer 5

`X extends Enum<Y>`

would be illegal. that is relavant. compiler can have special rules with enum, but why not have a perfect type declaration if possible?