Java 枚举和泛型

Question

这件事让我困扰了一段时间。我之前问过questions，但可能措辞不好，例子太抽象了。所以不清楚我实际上在问什么。我会再尝试。请不要妄下结论。我希望这个问题根本不容易回答！

为什么我不能在 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 ... ]
}

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

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 是语法糖。泛型也是如此。实际上，编译器完成了所有工作并将enums 转换为java.lang.Enum 的子类，并将泛型转换为强制类型转换和合成方法。

但为什么编译器不能更进一步并允许泛型枚举？

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

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

Answer 1

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

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

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

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

编辑：为了响应 cmets（以及 Tom - 否决票？），嵌套的泛型参数会导致各种坏事发生。枚举实现 Comparable。如果泛型在起作用，那根本无法比较客户端代码中枚举的两个任意元素。一旦你处理了一个泛型参数的泛型参数，你最终会遇到各种边界问题和令人头疼的问题。很难设计一个能很好地处理它的类。在可比较的情况下，我想不出一种方法来比较枚举的两个任意成员而不恢复为原始类型并获得编译器警告。可以吗？

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

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

Answer 2

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

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

人们必须在某个地方划清界限。仅仅因为一个类具有枚举实例，并不意味着它必须是一个枚举。如果它在其他领域足够成熟，它应该是一个常规课程。

在您的情况下，将 DataType 设为枚举并没有太大优势。您可以在 switch-case 中使用枚举，仅此而已，很重要。 DataType 的非枚举版本可以正常工作。

Answer 3

我是这么想的——

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

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

我希望这会有所帮助。

Answer 4

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

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

• 对于Datatype.INT：int parse(String)
• 对于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 行的断言都是真的。泛型类型在运行时不可用。

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

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

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

我希望这会有所帮助。

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