Почему литералы перечисления Java не должны иметь параметров общего типа?

Перечисления Java великолепны. Как и дженерики. Конечно, мы все знаем ограничения последнего из-за стирания типа. Но есть одна вещь, которую я не понимаю: почему я не могу создать перечисление вот так:

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

Этот параметр общего типа, <T>в свою очередь, может быть полезен в различных местах. Представьте параметр общего типа для метода:

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

Или даже в самом классе enum:

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 ()
• Универсальный тип <T> будет в перечислении. Следовательно, он связан каждым из литералов перечисления. Следовательно, компилятор будет знать, какой тип применять при написании чего-то вродеString string = LITERAL1.convert(myObject); Integer integer = LITERAL2.convert(myObject);
• То же самое относится к параметру универсального типа в T getvalue()методе. Компилятор может применять приведение типов при вызовеString string = someClass.getValue(LITERAL1)

Это сейчас обсуждается с расширенными перечислениями JEP-301 . Пример, приведенный в 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

Ответ в вопросе:

из-за стирания типа

Ни один из этих двух методов невозможен, так как тип аргумента стирается.

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

Однако, чтобы реализовать эти методы, вы можете построить свой enum следующим образом:

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

    private Class<?> clazz;

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

    ...

}

Потому что ты не можешь. Шутки в сторону. Это можно добавить к спецификации языка. Это не было Это добавило бы некоторую сложность. Эта выгода от стоимости означает, что она не является приоритетной.

Обновление: в настоящее время добавляется к языку в JEP 301: Enhanced Enums .

В ENUM есть другие методы, которые не работают. Что MyEnum.values()вернется?

Как насчет MyEnum.valueOf(String name)?

Для valueOf, если вы думаете, что компилятор может сделать общий метод, такой как

общедоступный статический MyEnum valueOf (имя строки);

чтобы это так назвать MyEnum<String> myStringEnum = MyEnum.value("some string property"), это тоже не сработало бы. Например, что если вы позвоните MyEnum<Int> myIntEnum = MyEnum.<Int>value("some string property")? Невозможно реализовать этот метод для правильной работы, например, чтобы выдать исключение или вернуть ноль, когда вы вызываете его как, MyEnum.<Int>value("some double property")из-за стирания типа.

Откровенно говоря, это больше похоже на решение проблемы, чем что-либо еще.

Вся цель перечисления java состоит в том, чтобы смоделировать перечисление экземпляров типов, которые имеют общие свойства таким образом, что обеспечивает согласованность и богатство, превосходящие сопоставимые представления String или Integer.

Возьмите пример перечисления учебника. Это не очень полезно или не соответствует:

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

Зачем мне хотеть, чтобы на разных планетах были разные преобразования типов? Какую проблему это решает? Оправдывает ли это усложнение языковой семантики? Если мне нужно такое поведение, является ли enum лучшим инструментом для достижения этого?

Кроме того, как бы вы управляли сложными конверсиями?

например

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

Достаточно просто String Integerуказать имя или порядковый номер. Но дженерики позволят вам поставить любой тип. Как бы вы справились с преобразованием в MyComplexClass? Теперь вы смешиваете две конструкции, заставляя компилятор знать, что существует ограниченное подмножество типов, которые могут быть предоставлены универсальным перечислениям, и вводите дополнительную путаницу в концепцию (Generics), которая, похоже, уже ускользает от многих программистов.

Becasue "enum" является аббревиатурой для перечисления. Это просто набор именованных констант, которые стоят вместо порядковых номеров, чтобы сделать код более читабельным.

Я не понимаю, каким может быть предполагаемое значение параметризованной константы.

Я думаю, потому что в основном нельзя перечислить Enums

Где бы вы установили класс T, если бы JVM позволила вам это сделать?

Перечисление - это данные, которые должны быть всегда одинаковыми или, по крайней мере, динамически не изменяться.

новый MyEnum <> ()?

Тем не менее, следующий подход может быть полезным

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