Por que os literais Java enum não deveriam ter parâmetros de tipo genérico?

Enums de Java são ótimas. O mesmo acontece com os genéricos. É claro que todos sabemos as limitações deste último por causa do apagamento de tipo. Mas há uma coisa que não entendo: por que não consigo criar uma enumeração como esta:

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

Esse parâmetro de tipo genérico, <T>por sua vez, pode ser útil em vários locais. Imagine um parâmetro de tipo genérico para um método:

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

Ou mesmo na própria classe enum:

public T convert(Object o);

Exemplo mais concreto nº 1

Como o exemplo acima pode parecer abstrato demais para alguns, aqui está um exemplo mais real do porquê eu quero fazer isso. Neste exemplo eu quero usar

• Enums, porque então eu posso enumerar um conjunto finito de chaves de propriedade
• Genéricos, porque então eu posso ter segurança de tipo no nível do método para armazenar propriedades

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

Exemplo mais concreto # 2

Eu tenho uma enumeração de tipos de dados:

public interface DataType<T> {}

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

Cada literal de enumeração obviamente teria propriedades adicionais baseadas no tipo genérico <T>, enquanto ao mesmo tempo seria uma enumeração (imutável, singleton, enumerável, etc. etc.)

Questão:

Ninguém pensou nisso? Isso é uma limitação relacionada ao compilador? Considerando o fato de que a palavra-chave " enum " é implementada como açúcar sintático, representando o código gerado para a JVM, não entendo essa limitação.

Quem pode me explicar isso? Antes de responder, considere o seguinte:

• Eu sei que tipos genéricos são apagados :-)
• Eu sei que existem soluções alternativas usando objetos de classe. Eles são soluções alternativas.
• Tipos genéricos resultam em transmissões de tipos gerados pelo compilador sempre que aplicável (por exemplo, ao chamar o método convert ()
• O tipo genérico <T> estaria na enumeração. Portanto, ele é vinculado por cada um dos literais da enumeração. Portanto, o compilador saberia qual tipo aplicar ao escrever algo comoString string = LITERAL1.convert(myObject); Integer integer = LITERAL2.convert(myObject);
• O mesmo se aplica ao parâmetro de tipo genérico no T getvalue()método O compilador pode aplicar a conversão de tipo ao chamarString string = someClass.getValue(LITERAL1)

Agora isso está sendo discutido no JEP-301 Enhanced Enums . O exemplo dado no JEP é exatamente o que eu estava procurando:

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

Infelizmente, o JEP ainda está enfrentando problemas significativos: http://mail.openjdk.java.net/pipermail/amber-spec-experts/2017-May/000041.html

A resposta está na pergunta:

por causa do tipo de apagamento

Nenhum desses dois métodos é possível, pois o tipo de argumento é apagado.

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

Para realizar esses métodos, você pode construir sua enumeração como:

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

    private Class<?> clazz;

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

    ...

}

Porque você não pode. Seriamente. Isso pode ser adicionado à especificação do idioma. Não foi. Isso acrescentaria alguma complexidade. Esse benefício de custo significa que não é uma alta prioridade.

Atualização: atualmente sendo adicionada ao idioma no JEP 301: Enums aprimoradas .

Existem outros métodos no ENUM que não funcionariam. O que seriaMyEnum.values() retornaria?

A respeito MyEnum.valueOf(String name) ?

Para o valueOf, se você acha que o compilador pode criar um método genérico como

public estático MyEnum valueOf (String name);

para chamar assim MyEnum<String> myStringEnum = MyEnum.value("some string property"), isso também não funcionaria. Por exemplo, e se você ligar MyEnum<Int> myIntEnum = MyEnum.<Int>value("some string property")? Não é possível implementar esse método para funcionar corretamente, por exemplo, para lançar uma exceção ou retornar nulo quando você o chama como MyEnum.<Int>value("some double property")por causa do tipo apagamento.

Francamente, isso parece mais uma solução em busca de um problema do que qualquer coisa.

O objetivo inteiro do java enum é modelar uma enumeração de instâncias de tipo que compartilhem propriedades semelhantes de uma maneira que forneça consistência e riqueza além das representações String ou Inteiro comparáveis.

Veja um exemplo de enum de livro de texto. Isso não é muito útil ou consistente:

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

Por que eu gostaria que meus planetas diferentes tivessem conversões de tipos genéricos diferentes? Qual problema isso resolve? Justifica complicar a semântica da linguagem? Se eu precisar desse comportamento, um enum é a melhor ferramenta para alcançá-lo?

Além disso, como você gerenciaria conversões complexas?

por exemplo

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

É fácil o suficiente String Integerpara fornecer o nome ou ordinal. Mas os genéricos permitiriam fornecer qualquer tipo. Como você gerenciaria a conversão MyComplexClass? Agora, você está criando duas construções forçando o compilador a saber que há um subconjunto limitado de tipos que podem ser fornecidos a enumerações genéricas e introduzindo uma confusão adicional ao conceito (Genéricos) que já parece iludir muitos programadores.

Porque "enum" é a abreviação de enumeração. É apenas um conjunto de constantes nomeadas que substituem os números ordinais para tornar o código melhor legível.

Não vejo qual poderia ser o significado pretendido de uma constante parametrizada por tipo.

Eu acho que porque basicamente Enums não podem ser instanciados

Onde você definiria a classe T, se a JVM permitisse?

Enumeração são dados que devem ser sempre os mesmos, ou pelo menos, que não serão alterados dinamicamente.

novo MyEnum <> ()?

Ainda a seguinte abordagem pode 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;
    }   
}