什么是Java中不同，如果枚举声明没有递归部分

Question

请参阅 Java Enum definition 和 Why in java enum is declared as Enum<E extends Enum<E>> 一般性讨论。在这里，我想了解究竟是什么将被打破（不是类型安全的了，或者需要额外的管型等），如果枚举类是测试我的想法定义为

public class Enum<E extends Enum> 

我使用这个代码：

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> {} 

有了它，我无法在这个确切的案例中找到任何好处。

PS。那我不能做

class ThirdEnum extends MyEnum<SecondEnum> {} 

时MyEnum与递归定义的事实是
一）不相关的，因为真正的枚举你不能这样做，只是因为你不能延长枚举你自己
b）不正确 - 请在编译器中试试看，它实际上能够编译没有任何错误

PPS。我越来越倾向于相信，这里的正确答案是“如果你删除递归部分，什么都不会改变” - 但我无法相信这一点。

Answer 1

我相信一个令人信服的理由是，它使MyEnum类中的代码更安全。

认为递归部分，使这样的事情成为可能：

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. 
    } 
} 

简言之，递归性可以让你把在枚举类，您可以任意E元素上调用类型安全的方法，并且这些调用会类型安全。

Answer 2

考虑Enum<E>.compareTo(E other)。

即：

• 需求为E而不是枚举工作，让你不要试图一个枚举值与值从不同的枚举
• 需求比较能够得到序枚举的值，通过ordinal()方法在Enum上声明。

您会如何提出在没有当前约束的情况下进行工作？

这只是我想出的第一个......我相信还有很多其他人。基本上这是一种说法，“你不应该试图把所有的枚举看作等价的 ......枚举本身是一个封闭的集合，但是所有的枚举都具有某些属性。”

Answer 3

嗯，首先它会抱怨使用原始类型的，但你可以这样做：

public class Enum<E extends Enum<?>> 

达到相同的效果。

而且，这种类型的通用的，你可以这样做：

class FirstEnum extends MyEnum<SecondEnum> { 
} 

class SecondEnum extends MyEnum<FirstEnum> { 
} 

这对我来说似乎是它可以导致很多的麻烦。更确切地说，您无法将FirstEnum类型的枚举与相同类型的枚举进行比较，您必须将其与其他类型的枚举进行比较，如果您要排序的List<FirstEnum>确实很麻烦。如果我设置E而不是?，此示例不会编译，因为SecondEnum的类型不是E extends MyEnum<E>（这会导致循环继承）。它会工作，如果FirstEnum extends MyEnum<FirstEnum>尽管（这将意味着SecondEnum是FirstEnum的子类 - 正常的分层继承）。

Answer 4

如果您没有泛型类型参数，那么您将无法为您创建的枚举的特定子类型扩展Comparable<T extends Comparable>。

你可以忽略这一点，并建立它的行为大同小异自己MyEnum类型，但没有限制，不同的MyEnum没有可比性：

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; 
    } 
} 

这种行为在几乎相同的方式作为一个枚举会为定义的操作，而不是泛型类型的安全实现服从LSP - 如果MyEnum的不同子类的对象具有相同的序数值，则它们可以相互比较或相等。

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)); 
} 

在这种情况下，如果不重写equals，你失去x.comparesTo(y)=0意味着x.equals(y)公约;如果你重写equals，那么有些情况下x.equals(y)并不意味着x == y（对于其他值对象），而对于Java枚举，两个相等的测试都会产生相同的结果。

Answer 5

`X extends Enum<Y>` 

将是非法的。那是相关。编译器可以有enum的特殊规则，但如果可能的话，为什么不能有一个完美的类型声明？