Come passare una classe parametrizzata come argomento

Question

Il mio obiettivo è sviluppare una classe che possa generare un oggetto di una classe specificata.

public class GetMe<T> { 
    public T get() { 
     Object obj = generateObject(); 
     return (T) obj; 
    } 
} 

Ora, so che questo non è possibile a causa della cancellazione. Quindi, possiamo passare in un'istanza di classe e usarlo per trasmettere.

public class GetMe<T> { 
    public GetMe<T>(Class<T> clazz) { 
     this.clazz = clazz; 
    } 

    public T get() { 
     Object obj = generateObject(); 
     return clazz.cast(obj); 
    } 
} 

Questo funziona benissimo! Finché la classe non è parametrizzata. Se lo è, allora ho un problema.

Non sono autorizzato a utilizzare List<String>.class. Se passo in un ParameterizedType (che di per sé è difficile da generare), non esiste un metodo cast da utilizzare.

Esiste un modo per uscire da questo pantano?

Answer 1

Il problema con List<String> è che, a causa della cancellazione, sarebbe in fase di esecuzione indistinguibile da qualsiasi altro List<?>. Il modo più semplice per aggirare questo è di creare una nuova classe o interfaccia che ha la parte generica "fisso", come

public interface StringList extends List<String> { 
    /* nothing to see here */ 
} 

In questo modo si dispone di un tipo di token (l'oggetto StringList.class), che è possibile passare in giro in fase di esecuzione e specifica esattamente ciò che vuoi, ma senza bisogno di generici in fase di runtime.

Answer 2

Ecco solo una piccola idea. Non sono sicuro che si adatti al tuo contesto, tuttavia:

public class GetMe<T> 
{ 
    public List<T> getList() { 
     @SuppressWarnings("unchecked") 
     List<T> result = (List<T>) new LinkedList(); 
     return result; 
    } 
} 

Cheers!

Answer 3

Penso che super type tokens possa risolvere questo problema per voi.

Answer 4

Il primo problema è come si pianifica di creare un'istanza di un oggetto List. Se divulgherai più di ciò che stai cercando di costruire, potremmo essere in grado di aiutarti meglio.

Si consiglia di utilizzare Tipo anziché Classe. Il tipo può rappresentare tutti i tipi generici, anche se non è piacevole lavorare con.

abstract public class GetMe<T> 
{ 
    Type type; 
    public GetMe<T>(Type type) 
    { 
     this.type = type; 
    } 
} 

Un altro problema è come creare un tipo generico come List<String>. Il "tipo di token super" sembra pulito nella sintassi, in realtà è praticamente

static class XX extends TypeReference<List<String>>{} 
.... 
Type typeListString = Util.extract(XX.class); 

io preferirei di gran lunga questo modo

List<String> f; 

Type typeListString = getDeclaredField("f").getGenericType(); 

In realtà, molti di questi quadri che fanno runtime fantasia magie generici stanno lavorando su solo campi di istanza.

Answer 5

Penso che la confusione derivi dal fatto che stai cercando di creare un oggetto da List<> che di fronte è un'interfaccia, non un oggetto.
Quindi, non importa quello che ci si provi, semplicemente non è possibile creare un'istanza di List<>, (le interfacce non sono classi effettivi, e non hanno costruttori)

provare a utilizzare un vincolo per evitare di avere messo le interfacce nella dichiarazione:

public class GetMe<T extends Object> 

Ciò garantisce che T è una classe reale e non un'interfaccia.