Classe di memoria generica nel campo in Java

Question

Esiste un modo per memorizzare il tipo di parametro generico passato in costruzione a un parametro. Il mio obiettivo:

class generic<T> { 
    Class<T> type; 
    public generic() { 
     super(); 
     this.type = //Something that gets class from T 
    } 
} 

Quello che sto facendo attualmente è questa:

class generic<T> { 
    Class<T> type; 
    public generic(Class<T> type) { 
     super(); 
     this.type = type; 
    } 
} 

Sembra stupido dover specificare la classe due volte, ma non sono sicuro di quale altro modo per farlo. Penso che questo potrebbe essere possibile con la riflessione, ma non l'ho ancora studiato. C'è un modo più diretto? Se no (a parte) perché la perdita di informazioni?

Answer 1

Perché generici Java sono implementati con Type Erasure

Quando un tipo generico viene creata un'istanza, il compilatore traduce quei tipi da una tecnica chiamata tipo cancellazione - un processo in cui il compilatore rimuove tutte informazioni relative al digitare i parametri e digitare gli argomenti all'interno di una classe o il metodo . La cancellazione di tipo abilita le applicazioni Java che usano i generici per mantenere la compatibilità binaria con le librerie e le applicazioni Java che sono state create prima dei generici.

Answer 2

Penso che non puoi farlo a causa di type erasure.

Answer 3

Il tipo non viene mantenuto in fase di esecuzione, quindi non è possibile utilizzarlo come parametro. Generics in java sono strettamente un concetto in fase di compilazione (per ragioni di compatibilità all'indietro). Questo è chiamato Type Erasure.

Uno dei motivi per cui l'oggetto classe accetta un parametro di tipo è proprio quello di aggirare questo problema, quindi è possibile prendere l'oggetto di classe per rappresentare il tipo in modo programmatico.

Answer 4

Se si utilizza un metodo di creazione statica con l'inferenza di tipo anziché il costruttore, non è necessario specificare il tipo due volte.

final class Generic<T> { 
    private final Class<T> type; 
    private Generic(Class<T> type) { 
     super(); 
     if (type == null) { 
      throw new NullPointerException(); 
     } 
     this.type = type; 
    } 
    public static <T> Generic<T> newInstance(Class<T> clazz) { 
     return new Generic<T>(clazz); 
    } 
} 
... 
    someFunction(Generic.newInstance(SomeType.class)); 

Naturalmente, se si desidera memorizzare il risultato in una variabile, si sono probabilmente andando a ripetere il tipo comunque!