Creazione di oggetto tipo parametrizzato usando la classe anonima

Question

Questa potrebbe essere una domanda stupida, ma ho appena visto una domanda che chiede how to create a Type variable for a generic type. Il consenso sembrava essere che dovresti avere un metodo fittizio che restituisce quel tipo, e quindi usare reflection per ottenerlo (in questo caso voleva Map<String, String>). Qualcosa di simile a questo:

public Map<String, String> dummy() { throw new Error(); } 

Type mapStringString = Class.forName("ThisClass").getMethod("dummy").getGenericReturnType(); 

La mia domanda è, non avendo riflessione utilizzato più di tanto, non poteva semplicemente fare qualcosa di simile:

Type mapStringString = new ParameterizedType() { 
    public Type getRawType() { 
     return Map.class; 
    } 

    public Type getOwnerType() { 
     return null; 
    } 

    public Type[] getActualTypeArguments() { 
     return new Type[] { String.class, String.class }; 
    } 
}; 

Sarebbe questo lavoro? Se no, perché no? E quali sono alcuni dei pericoli/problemi se lo fa (oltre ad essere in grado di restituire un certo tipo, come Integer<String> che non è ovviamente possibile.

Answer 1

sicuro che si poteva, e per la maggior parte delle applicazioni che sarebbe probabilmente sufficiente.

Tuttavia, utilizzando il primo metodo, si ottiene un oggetto più raffinato. Ad esempio, si crea un oggetto type1 utilizzando il primo metodo e type2 utilizzando il secondo metodo, quindi type1.equals(type2) restituisce true (poiché il primo metodo restituisce un oggetto che implementa correttamente il metodo equals) ma type2.equals(type1) restituisce false (poiché nel secondo metodo, non hai sovrascritto il metodo equals e stai usando l'implementazione da Object).

stesso ragionamento vale per altri metodi (talvolta utili) come toString, hashCode ecc Il secondo metodo non fornisce implementazioni utili di questi.

Answer 2

In realtà, penso che il modo più semplice (== codice minimo) per farlo sarebbe un'interfaccia fittizia che estenda il tipo a cui sei interessato, e quindi getGenericInterfaces()[0] dalla sua classe (usa getGenericSuperclass() se sei interessato a una classe) :

private interface MapStringString extends Map<String, String> {} 
private static ParameterizedType mapStringString(){ 
    return (ParameterizedType) MapStringString.class.getGenericInterfaces()[0]; 
} 

E doen't scala bene, anche se, come è necessario creare una nuova classe per ogni ParameterizedType si vuole rappresentare. Non vedo perché la tua implementazione non funzionerebbe (a meno che non ci siano limiti di cast da qualche parte), e ha il vantaggio allettante che puoi renderlo riutilizzabile.

Answer 3

Se includi la libreria di Google Guava nel tuo progetto (dovresti, è fantastico), usa il suo TypeToken per ottenere un tipo. La libreria di Google Gson (per l'interazione con JSON) ha un valore simile a version. Entrambi sono utilizzati come questo (per ottenere un Type che rappresenta List<String>:

Type t = new TypeToken<List<String>>(){}.getType(); 

Se non si vuole fare affidamento su eventuali librerie di terze parti, è comunque possibile utilizzare i tipi anonimi per ottenere un generico concreta tipo con . una riga di codice (questa tecnica non funziona con le interfacce e potrebbe essere più problemi che ne vale la pena per tipi astratti) per ottenere un Type che rappresenta HashMap<String, String>, fare questo:

Type t = new HashMap<String, String>(){}.getClass().getGenericSuperclass(); 

ho verificato che risulta Type istanza .equals() le istanze Type create da Gson 's TypeToken, sebbene non abbiano verificato lo stesso per la versione Guava di TypeToken, a cui non ho accesso al momento.(Guava è una libreria più generica che è così utile per tutti i tipi di cose, dovresti probabilmente usarla comunque.)