Java 枚举和泛型

Question

这件事现在困扰我一段时间了。我问了问题以前，但可能措辞不好，例子也太抽象。所以不清楚我实际上在问什么。我会再试一次。请不要急于下结论。我想这个问题并不容易回答！

为什么我不能在 Java 中使用带有泛型类型参数的枚举？

问题不在于为什么它在语法上不可能。我知道它只是不受支持。问题是：为什么JSR人们“忘记”或“省略”了这个非常有用的功能？我无法想象与编译器相关的原因，为什么它不可行。

这就是我想做的事情。这在 Java 中是可能的。这是创建类型安全枚举的 Java 1.4 方法：

// A model class for SQL data types and their mapping to Java types
public class DataType<T> implements Serializable, Comparable<DataType<T>> {
    private final String name;
    private final Class<T> type;

    public static final DataType<Integer> INT      = new DataType<Integer>("int", Integer.class);
    public static final DataType<Integer> INT4     = new DataType<Integer>("int4", Integer.class);
    public static final DataType<Integer> INTEGER  = new DataType<Integer>("integer", Integer.class);
    public static final DataType<Long>    BIGINT   = new DataType<Long>   ("bigint", Long.class);    

    private DataType(String name, Class<T> type) {
        this.name = name;
        this.type = type;
    }

    // Returns T. I find this often very useful!
    public T parse(String string) throws Exception {
        // [...]
    }

    // Check this out. Advanced generics:
    public T[] parseArray(String string) throws Exception {
        // [...]
    }

    // Even more advanced:
    public DataType<T[]> getArrayType() {
        // [...]
    }

    // [ ... more methods ... ]
}

然后，您可以在许多其他地方使用

public class Utility {

    // Generic methods...
    public static <T> T doStuff(DataType<T> type) {
        // [...]
    }
}

但这些事情对于枚举来说是不可能的：

// This can't be done
public enum DataType<T> {

    // Neither can this...
    INT<Integer>("int", Integer.class), 
    INT4<Integer>("int4", Integer.class), 

    // [...]
}

现在，正如我所说。我知道这些东西就是这样设计的。 enum 是语法糖。仿制药也是如此。实际上，编译器完成了所有工作，并将枚举转换为 java.lang.Enum 的子类，将泛型转换为强制转换和合成方法。

但是为什么编译器不能更进一步并允许通用枚举？

编辑： 这是我所期望的编译器生成的 Java 代码：

public class DataType<T> extends Enum<DataType<?>> {
    // [...]
}

Answer 1

我会猜测一下，这是因为 Enum 类本身的类型参数的协方差问题，它被定义为 Enum>，尽管调查所有的极端情况有点太多了。

除此之外，枚举的主要用例是像 EnumSet 和 valueOf 这样的东西，你有一个具有不同泛型参数的集合，并从字符串中获取值，所有这些都不会支持或更糟枚举本身的泛型参数。

我知道，当我尝试使用泛型时，我总是处于痛苦的世界中，我想象语言设计者看到了那个深渊，并决定不去那里，特别是因为这些功能是同时开发的，这意味着甚至Enum 方面的不确定性更大。

或者换句话说，在处理本身具有泛型参数的类时，它会遇到 Class 的所有问题，并且您必须进行大量转换和处理原始类型。语言设计者认为对于您正在查看的用例类型而言，这并不是真正值得的事情。

编辑：为了回应评论（和汤姆 - 否决票？），嵌套通用参数会导致各种不好的事情发生。 Enum 实现了 Comparable。如果使用泛型，则根本无法比较客户端代码中枚举的两个任意元素。一旦处理了泛型参数的泛型参数，您最终会遇到各种边界问题和令人头痛的问题。设计一个能够很好地处理它的类是很困难的。在可比较的情况下，我无法找到一种方法来使其可以比较枚举的两个任意成员，而无需恢复为原始类型并获得编译器警告。可以吗？

实际上，上面的内容是令人尴尬的错误，因为我使用问题中的 DataType 作为思考这个问题的模板，但实际上 Enum 会有一个子类，所以这不太正确。

不过，我坚持我的回答的要点。 Tom 提出了 EnumSet.complementOf，当然我们仍然有 valueOf 会产生问题，并且就 Enum 的设计可能起作用的程度而言，我们必须意识到这是一个事后诸葛亮的事情。枚举是与泛型同时设计的，并且没有验证所有此类极端情况的好处。特别是考虑到具有通用参数的 Enum 的用例相当有限。 （但话又说回来，EnumSet 的用例也是如此）。

Answer 2

我不认为泛化枚举是不可能的。如果您可以侵入编译器，则可以拥有通用的 Enum 子类，并且通用枚举的类文件不会导致问题。

但最终，枚举几乎是一种语法糖。在 C、C++、C# 中，枚举基本上是 int 常量的别名。 Java 赋予了它更多的功能，但它仍然应该来表示简单的项目。

人们必须在某个地方划清界限。仅仅因为一个类具有枚举实例，并不意味着它必须是一个枚举。如果它在其他方面足够复杂，那么它就应该成为一个普通的课程。

就您而言，将 DataType 设为枚举并没有太大优势。你可以在 switch-case 中使用枚举，仅此而已，很重要。 DataType 的非枚举版本工作得很好。

Answer 3

这就是我的想法——

常规类有实例。您创建一个类的新实例，将其用于某种目的，然后将其处置。例如 List 是字符串列表。我可以用字符串做任何我想做的事情，然后当我完成后，我可以用整数做同样的功能。

对我来说，枚举器不是您创建实例的类型。它和单例是一样的。所以我可以明白为什么 JAVA 不允许 Enum 泛型，因为你确实无法创建 Enum 类型的新实例来像使用类一样使用临时实例。枚举应该是静态的，并且全局只有一个实例。对我来说，允许全局只有一个实例的类使用泛型是没有意义的。

我希望这有帮助。

Answer 4

我认为您希望使用 参数化枚举的原因归结为能够为枚举的各种常量拥有不同的方法签名。

在您的示例中，parse 的签名（参数类型和返回类型）为：

• for Datatype.INT: int parse(String)
• for Datatype.VARCHAR: String parse(String)
• 等等

那么编译器如何能够进行类似以下内容的类型检查：

Datatype type = ...
...
int x = type.parse("45");

???

要对此类表达式应用静态类型和类型检查，所有实例的方法签名必须相同。然而，最后你建议为不同的实例使用不同的方法签名......这就是为什么在 Java 中不可能做到这一点。

Answer 5

public enum GenericEnum<T> {
  SIMPLE, COMPLEX;

  public T parse(String s) {
    return T.parse(s);
  }
}

public void doSomething() {
  GenericEnum<Long> longGE = GenericEnum<Long>.SIMPLE;
  GenericEnum<Integer> intGE = GenericEnum<Integer>.SIMPLE;

  List<Long> longList = new LinkedList<Long>();
  List<Integer> intList = new LinkedList<Integer>();

  assert(longGE == intGE);              // 16
  assert(stringList.equals(intList));   // 17

  Object x = longGE.parse("1");  // 19
}

第 16 行和第 17 行的断言均为 true。泛型类型在运行时不可用。

枚举的优点之一是您可以使用 == 来比较它们。第 16 行的断言将评估为 true。

但在第 19 行我们遇到了一个问题。 longGE 和 intGE 是同一个对象（如第 16 行的断言所示）。parse("1") 将返回什么？通用类型信息在运行时不可用。因此无法在运行时确定解析方法的 T。

枚举基本上是静态的，它们只存在一次。将泛型类型应用于静态类型是没有意义的。

我希望这有帮助。

注意 - 这并不意味着是工作代码。它使用原始问题中建议的语法。