为什么 Java 枚举文字不能具有泛型类型参数？

Question

Java 枚举很棒。泛型也是如此。当然，我们都知道后者由于类型擦除的局限性。但是有一件事我不明白，为什么我不能像这样创建一个枚举：

public enum MyEnum<T> {
    LITERAL1<String>,
    LITERAL2<Integer>,
    LITERAL3<Object>;
}

这个泛型类型参数<T> 反过来又可以在不同的地方使用。想象一个方法的泛型类型参数：

public <T> T getValue(MyEnum<T> param);

甚至在枚举类本身中：

public T convert(Object o);

更具体的例子#1

由于上面的例子对某些人来说可能看起来太抽象了，这里有一个更真实的例子来说明我为什么要这样做。在这个例子中我想使用

• 枚举，因为这样我就可以枚举一组有限的属性键
• 泛型，因为这样我就可以拥有存储属性的方法级类型安全性

public interface MyProperties {
     public <T> void put(MyEnum<T> key, T value);
     public <T> T get(MyEnum<T> key);
}

更具体的例子#2

我有一个数据类型的枚举：

public interface DataType<T> {}

public enum SQLDataType<T> implements DataType<T> {
    TINYINT<Byte>,
    SMALLINT<Short>,
    INT<Integer>,
    BIGINT<Long>,
    CLOB<String>,
    VARCHAR<String>,
    ...
}

每个枚举字面量显然都有基于泛型类型<T> 的附加属性，同时又是一个枚举（不可变、单例、可枚举等）

问题：

没有人想到这一点吗？这是与编译器相关的限制吗？考虑到关键字“enum”被实现为语法糖，代表生成的代码到JVM，我不明白这个限制。

谁能给我解释一下？在你回答之前，请考虑一下：

• 我知道泛型类型已被删除 :-)
• 我知道有一些使用类对象的解决方法。它们是变通方法。
• 泛型类型会在适用的情况下导致编译器生成类型转换（例如，在调用 convert() 方法时
• 泛型类型 将位于枚举中。因此，它受每个枚举字面量的约束。因此编译器会知道，在编写String string = LITERAL1.convert(myObject); Integer integer = LITERAL2.convert(myObject); 之类的内容时应用哪种类型
• 这同样适用于T getvalue() 方法中的泛型类型参数。编译器可以在调用String string = someClass.getValue(LITERAL1) 时应用类型转换

Answer 1

从JEP-301 Enhanced Enums 开始讨论这个问题，很遗憾，它被撤回了。 JEP 中给出的示例正是我想要的：

enum Argument<X> { // declares generic enum
   STRING<String>(String.class), 
   INTEGER<Integer>(Integer.class), ... ;

   Class<X> clazz;

   Argument(Class<X> clazz) { this.clazz = clazz; }

   Class<X> getClazz() { return clazz; }
}

Class<String> cs = Argument.STRING.getClazz(); //uses sharper typing of enum constant

不幸的是，JEP 正在努力解决无法解决的重大问题：http://mail.openjdk.java.net/pipermail/amber-spec-experts/2017-May/000041.html

Answer 2

答案就在问题中：

因为类型擦除

这两种方法都不可行，因为参数类型已被删除。

public <T> T getValue(MyEnum<T> param);
public T convert(Object);

要实现这些方法，您可以将枚举构造为：

public enum MyEnum {
    LITERAL1(String.class),
    LITERAL2(Integer.class),
    LITERAL3(Object.class);

    private Class<?> clazz;

    private MyEnum(Class<?> clazz) {
      this.clazz = clazz;
    }

    ...

}

Answer 3

因为你不能。严重地。这可以添加到语言规范中。它没有。它会增加一些复杂性。成本效益意味着它不是高优先级。

更新：目前正在添加到JEP 301: Enhanced Enums 下的语言中。

Answer 4

ENUM 中还有其他方法不起作用。 MyEnum.values() 会返回什么？

MyEnum.valueOf(String name) 呢？

对于 valueOf，如果你认为编译器可以制作像

这样的泛型方法

public static MyEnum valueOf(String name);

为了像MyEnum<String> myStringEnum = MyEnum.value("some string property") 那样称呼它，那也行不通。 例如，如果您拨打 MyEnum<Int> myIntEnum = MyEnum.<Int>value("some string property") 怎么办？ 由于类型擦除，无法实现该方法以正常工作，例如当您像 MyEnum.<Int>value("some double property") 一样调用它时抛出异常或返回 null。

Answer 5

坦率地说，这似乎更像是一种寻找问题的解决方案。

java 枚举的全部目的是对共享相似属性的类型实例的枚举进行建模，以提供超出可比较的字符串或整数表示形式的一致性和丰富性。

以教科书枚举为例。这不是很有用或一致：

public enum Planet<T>{
    Earth<Planet>,
    Venus<String>,
    Mars<Long>
    ...etc.
}

为什么我希望我的不同行星有不同的泛型类型转换？它解决了什么问题？它是否证明使语言语义复杂化是合理的？如果我确实需要这种行为，那么枚举是实现它的最佳工具吗？

另外，您将如何管理复杂的转化？

实例

public enum BadIdea<T>{
   INSTANCE1<Long>,
   INSTANCE2<MyComplexClass>;
}

使用String Integer 很容易提供名称或序号。但是泛型将允许您提供任何类型。您将如何管理到MyComplexClass 的转换？现在，您通过强制编译器知道可以提供给泛型枚举的类型的有限子集并给概念（泛型）引入了似乎已经让很多程序员难以理解的额外混淆，从而混淆了两个构造。

Answer 6

通过使用这个Java注解处理器https://github.com/cmoine/generic-enums，你可以写出类似的东西（convert方法被实现为一个例子）：

import org.cmoine.genericEnums.GenericEnum;
import org.cmoine.genericEnums.GenericEnumParam;

@GenericEnum
public enum MyEnum {
    LITERAL1(String.class) {
        @Override
        @GenericEnumParam
        public Object convert(Object o) {
            return o.toString(); // example
        }
    },
    LITERAL2(Integer.class) {
        @Override
        @GenericEnumParam
        public Object convert(Object o) {
            return o.hashCode(); // example
        }
    },
    LITERAL3(Object.class) {
        @Override
        @GenericEnumParam
        public Object convert(Object o) {
            return o; // example
        }
    };

    MyEnum(Class<?> clazz) {
    }

    @GenericEnumParam
    public abstract Object convert(Object o);
}

注解处理器会生成一个枚举MyEnumExt（可定制），它克服了java枚举的限制。相反，它会生成一个可完全用作枚举的 Java 类（最后，将枚举编译为实现 Enum 的 Java 类！）。

Answer 7

因为“enum”是枚举的缩写。 它只是一组命名常量，用来代替序数以使代码更具可读性。

我不明白类型参数化常量的预期含义是什么。

Answer 8

我认为因为基本上枚举不能被实例化

如果 JVM 允许，你会在哪里设置 T 类？

枚举是应该始终相同的数据，或者至少不会发生动态变化的数据。

新的我的枚举()?

以下方法可能仍然有用

public enum MyEnum{

    LITERAL1("s"),
    LITERAL2("a"),
    LITERAL3(2);

    private Object o;

    private MyEnum(Object o) {
        this.o = o;
    }

    public Object getO() {
        return o;
    }

    public void setO(Object o) {
        this.o = o;
    }   
}