Perché i letterali di enum Java non dovrebbero avere parametri di tipo generico?

Gli enumerati Java sono fantastici. Lo sono anche i generici. Naturalmente conosciamo tutti i limiti di quest'ultimo a causa della cancellazione del tipo. Ma c'è una cosa che non capisco, perché non posso creare un enum come questo:

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

Questo parametro di tipo generico <T>a sua volta potrebbe quindi essere utile in vari punti. Immagina un parametro di tipo generico in un metodo:

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

O anche nella stessa classe enum:

public T convert(Object o);

Esempio più concreto n. 1

Poiché l'esempio sopra potrebbe sembrare troppo astratto per alcuni, ecco un esempio più reale del perché voglio farlo. In questo esempio voglio usare

• Enum, perché poi posso enumerare un set finito di chiavi di proprietà
• Generici, perché allora posso avere una sicurezza del tipo a livello di metodo per la memorizzazione delle proprietà

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

Esempio più concreto n. 2

Ho un elenco di tipi di dati:

public interface DataType<T> {}

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

Ogni enum letterale avrebbe ovviamente proprietà aggiuntive basate sul tipo generico <T>, mentre allo stesso tempo sarebbe un enum (immutabile, singleton, enumerabile, ecc. Ecc.)

Domanda:

Nessuno ci ha pensato? Si tratta di una limitazione relativa al compilatore? Considerando il fatto che la parola chiave " enum " è implementata come zucchero sintattico, che rappresenta il codice generato per la JVM, non capisco questa limitazione.

Chi può spiegarmelo? Prima di rispondere, considera questo:

• So che i tipi generici vengono cancellati :-)
• So che ci sono soluzioni alternative usando gli oggetti Class. Sono soluzioni alternative.
• I tipi generici generano cast di tipi generati dal compilatore ove applicabile (ad es. Quando si chiama il metodo convert ()
• Il tipo generico <T> sarebbe sull'enum. Quindi è vincolato da ciascuno dei letterali dell'enum. Quindi il compilatore saprebbe quale tipo applicare per scrivere qualcosa di simileString string = LITERAL1.convert(myObject); Integer integer = LITERAL2.convert(myObject);
• Lo stesso vale per il parametro di tipo generico nel T getvalue()metodo. Il compilatore può applicare il cast di tipo durante la chiamataString string = someClass.getValue(LITERAL1)

Questo è ora in discussione a partire da Enumer Enhanced JEP-301 . L'esempio fornito nel JEP è, che è esattamente quello che stavo cercando:

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

Sfortunatamente, il JEP è ancora alle prese con problemi significativi: http://mail.openjdk.java.net/pipermail/amber-spec-experts/2017-May/000041.html

La risposta è nella domanda:

a causa della cancellazione del tipo

Nessuno di questi due metodi è possibile, poiché il tipo di argomento viene cancellato.

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

Per realizzare quei metodi potresti comunque costruire il tuo enum come:

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

    private Class<?> clazz;

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

    ...

}

Perché non puoi. Sul serio. Ciò potrebbe essere aggiunto alle specifiche della lingua. Non è stato Aggiungerebbe una certa complessità. Tale vantaggio per i costi significa che non è una priorità assoluta.

Aggiornamento: attualmente aggiunto alla lingua in JEP 301: Enhanced Enums .

Ci sono altri metodi in ENUM che non funzionerebbero. Cosa sarebbe MyEnum.values()tornato?

Che dire MyEnum.valueOf(String name)?

Per il valoreSe pensi che quel compilatore possa rendere simile un metodo generico

valore pubblico MyEnum staticoOf (nome stringa);

per chiamarlo così MyEnum<String> myStringEnum = MyEnum.value("some string property"), neanche quello avrebbe funzionato. Ad esempio, se chiami MyEnum<Int> myIntEnum = MyEnum.<Int>value("some string property")? Non è possibile implementare quel metodo per funzionare correttamente, ad esempio per generare un'eccezione o restituire null quando lo si chiama come a MyEnum.<Int>value("some double property")causa della cancellazione del tipo.

Francamente questa sembra più una soluzione alla ricerca di un problema che altro.

L'intero scopo dell'enumerazione Java è di modellare un'enumerazione di istanze di tipo che condividono proprietà simili in modo da fornire coerenza e ricchezza oltre a quelle di rappresentazioni String o Integer comparabili.

Prendi un esempio di enum di un libro di testo. Questo non è molto utile o coerente:

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

Perché dovrei desiderare che i miei diversi pianeti abbiano conversioni di tipo generico diverso? Che problema risolve? Giustifica la complicazione della semantica linguistica? Se ho bisogno di questo comportamento è un enum lo strumento migliore per raggiungerlo?

Inoltre come gestiresti conversioni complesse?

per esempio

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

È abbastanza facile String Integerfornire il nome o l'ordinale. Ma i generici ti permetterebbero di fornire qualsiasi tipo. Come gestiresti la conversione MyComplexClass? Ora fai confondere due costrutti costringendo il compilatore a sapere che ci sono un sottoinsieme limitato di tipi che possono essere forniti a enum generici e introducendo ulteriore confusione nel concetto (Generics) che sembra già sfuggire a molti programmatori.

Perché "enum" è l'abbreviazione di enumerazione. È solo un insieme di costanti nominate che sostituiscono i numeri ordinali per rendere il codice più leggibile.

Non vedo quale potrebbe essere il significato previsto di una costante con parametri di tipo.

Penso perché fondamentalmente Enums non può essere istanziato

Dove imposteresti la classe T, se JVM ti permettesse di farlo?

L'enumerazione è un dato che dovrebbe essere sempre lo stesso, o almeno, che non cambierà dinamicamente.

nuovo MyEnum <> ()?

Tuttavia, può essere utile il seguente approccio

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