¿Por qué los literales Java enum no deberían tener parámetros de tipo genérico?

Las enumeraciones de Java son geniales. Así son los genéricos. Por supuesto, todos conocemos las limitaciones de este último debido al tipo de borrado. Pero hay una cosa que no entiendo, ¿por qué no puedo crear una enumeración como esta:

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

Este parámetro de tipo genérico <T>a su vez podría ser útil en varios lugares. Imagine un parámetro de tipo genérico para un método:

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

O incluso en la clase enum:

public T convert(Object o);

Ejemplo más concreto # 1

Dado que el ejemplo anterior puede parecer demasiado abstracto para algunos, aquí hay un ejemplo más real de por qué quiero hacer esto. En este ejemplo quiero usar

• Enums, porque entonces puedo enumerar un conjunto finito de claves de propiedad
• Genéricos, porque entonces puedo tener seguridad de tipos a nivel de método para almacenar propiedades

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

Ejemplo más concreto # 2

Tengo una enumeración de tipos de datos:

public interface DataType<T> {}

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

Cada enum literal obviamente tendría propiedades adicionales basadas en el tipo genérico <T>, al mismo tiempo que sería una enumeración (inmutable, singleton, enumerable, etc., etc.)

Pregunta:

¿Nadie pensó en esto? ¿Es esta una limitación relacionada con el compilador? Teniendo en cuenta el hecho de que la palabra clave " enum " se implementa como azúcar sintáctico, que representa el código generado para la JVM, no entiendo esta limitación.

¿Quién me puede explicar esto? Antes de responder, considere esto:

• Sé que los tipos genéricos se borran :-)
• Sé que hay soluciones alternativas al usar objetos de clase. Son soluciones alternativas.
• Los tipos genéricos resultan en conversiones de tipo generadas por el compilador cuando corresponda (por ejemplo, al llamar al método convert ()
• El tipo genérico <T> estaría en la enumeración. Por lo tanto, está obligado por cada uno de los literales de la enumeración. Por lo tanto, el compilador sabría qué tipo aplicar al escribir algo comoString string = LITERAL1.convert(myObject); Integer integer = LITERAL2.convert(myObject);
• Lo mismo se aplica al parámetro de tipo genérico en el T getvalue()método. El compilador puede aplicar la conversión de tipos al llamarString string = someClass.getValue(LITERAL1)

Esto ahora se está discutiendo a partir de las enumeraciones mejoradas JEP-301 . El ejemplo dado en el JEP es, que es precisamente lo que estaba buscando:

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

Desafortunadamente, el JEP todavía está luchando con problemas importantes: http://mail.openjdk.java.net/pipermail/amber-spec-experts/2017-May/000041.html

La respuesta está en la pregunta:

por el tipo de borrado

Ninguno de estos dos métodos es posible, ya que el tipo de argumento se borra.

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

Sin embargo, para realizar esos métodos, podría construir su enumeración como:

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

    private Class<?> clazz;

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

    ...

}

Porque no puedes Seriamente. Eso podría agregarse a la especificación del idioma. No ha sido Agregaría algo de complejidad. Ese beneficio para el costo significa que no es una alta prioridad.

Actualización: Actualmente se está agregando al lenguaje bajo JEP 301: Enums mejorados .

Hay otros métodos en ENUM que no funcionarían. ¿Qué MyEnum.values()volvería?

¿Qué hay de MyEnum.valueOf(String name)?

Por el valor de si crees que el compilador podría hacer un método genérico como

public static MyEnum valueOf (nombre de cadena);

para llamarlo así MyEnum<String> myStringEnum = MyEnum.value("some string property"), tampoco funcionaría. Por ejemplo, ¿qué pasa si llamas MyEnum<Int> myIntEnum = MyEnum.<Int>value("some string property")? No es posible implementar ese método para que funcione correctamente, por ejemplo, para lanzar una excepción o devolver un valor nulo cuando lo llama como MyEnum.<Int>value("some double property")debido a la eliminación de tipo.

Francamente, esto parece más una solución en busca de un problema que otra cosa.

El propósito completo de la enumeración de Java es modelar una enumeración de instancias de tipo que comparten propiedades similares de una manera que proporciona consistencia y riqueza más allá de las representaciones de cadenas o enteros comparables.

Tome un ejemplo de una enumeración de libros de texto. Esto no es muy útil o consistente:

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

¿Por qué querría que mis diferentes planetas tengan diferentes conversiones de tipo genérico? ¿Qué problema soluciona? ¿Justifica complicar la semántica del lenguaje? Si necesito este comportamiento, ¿es una enumeración la mejor herramienta para lograrlo?

Además, ¿cómo gestionaría conversiones complejas?

por ejemplo

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

Es bastante fácil String Integerproporcionar el nombre u ordinal. Pero los genéricos le permitirían suministrar cualquier tipo. ¿Cómo gestionarías la conversión MyComplexClass? Ahora está compilando dos construcciones forzando al compilador a saber que hay un subconjunto limitado de tipos que se pueden suministrar a enumeraciones genéricas e introduciendo confusión adicional al concepto (genéricos) que ya parece eludir a muchos programadores.

Porque "enum" es la abreviatura de enumeración. Es solo un conjunto de constantes con nombre que se colocan en lugar de números ordinales para hacer que el código sea mejor legible.

No veo cuál podría ser el significado previsto de una constante parametrizada por tipo.

Creo que porque básicamente las enumeraciones no pueden ser instanciadas

¿Dónde establecerías la clase T si JVM te lo permitiera?

La enumeración es información que se supone que es siempre la misma, o al menos, que no cambiará dinámicamente.

nuevo MyEnum <> ()?

Aún así, el siguiente enfoque puede ser útil

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