如果 Enum 声明没有递归部分，Java 中会有什么不同

Question

请参阅 Java 枚举定义 和 为什么在java中枚举被声明为Enum> 供一般性讨论。在这里，我想了解如果定义了 Enum 类，因为

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

有了它，我无法找到任何好处在这种情况下。

附言。 我不允许这样做的事实

class ThirdEnum extends MyEnum<SecondEnum> {}

当 MyEnum 用递归定义时 是
a）不相关，因为对于真正的枚举，您不能仅仅因为自己无法扩展枚举而这样做
b) 不正确 - 请在编译器中尝试一下，看看它实际上能够编译，没有任何错误

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

Answer 1

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

public class Enum<E extends Enum<?>>

以获得相同的效果。

另外，使用这种类型的泛型，您可以执行以下操作：

class FirstEnum extends MyEnum<SecondEnum> {
}

class SecondEnum extends MyEnum<FirstEnum> {
}

在我看来，这可能会导致很多麻烦。更确切地说，您不能将 FirstEnum 类型的枚举与相同类型的枚举进行比较，您必须将其与其他类型的枚举进行比较，如果您有一个 ListList 你想要排序的。如果我设置 E 而不是 ?，则该示例将无法编译，因为 SecondEnum 不是 E extends MyEnum 类型（这会导致循环继承）。如果 FirstEnum extends MyEnum 它将起作用（这意味着 SecondEnum 是 FirstEnum 的子类 - 正常的层次继承）。

Answer 2

我相信这样做的一个令人信服的理由是它使 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.
    }
}

简而言之，递归性允许您将类型安全的方法放入 Enum 类中，您可以在任何 E 元素上调用这些方法，并且这些调用将是类型安全的。

Answer 3

考虑Enum.compareTo(E other)。

那：

• 需要使用 E 而不是枚举，这样您就不会尝试将一个枚举值与另一个枚举中的值进行比较
• 需要能够通过ordinal() 获取枚举的序数值 方法在Enum上声明。

您建议如何在没有当前限制的情况下实现这一目标？

这只是我想出的第一个……我相信还有很多其他的。基本上，它是一种说法，“你不应该尝试将所有枚举视为彼此等效......枚举本身是一个封闭的集合，但所有枚举都共享某些属性。”

Answer 4

如果您没有泛型类型参数，那么您将无法为您创建的枚举的特定子类型扩展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 有特殊规则，但如果可能的话，为什么不拥有完美的类型声明呢？