Generici Java: ottieni lezione?

Question

Ho ottenuto un elenco, programmato in questo modo: public class MyList<T>. C'è un modo per usare la variabile T per ottenere il nome di classe (quindi posso, da MyList, sapere se T è String, Socket, ecc.)?

EDIT: Nevermind, ha trovato la risposta here.

Answer 1

Risposta breve: non è possibile.

Risposta lunga:

causa il modo in cui i farmaci generici è implementato in Java, il tipo generico T non è mantenuto in fase di esecuzione. Ancora, è possibile utilizzare un membro dati privato:

public class Foo<T> 
{ 
    private Class<T> type; 

    public Foo(Class<T> type) { this.type = type; } 
} 

Answer 2

Si sta vedendo il risultato di Type Erasure. Da quella pagina ...

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 ai parametri di tipo e tipo argomenti all'interno di una classe o 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.

Ad esempio, Box <String> è tradotto a forma di scatola, che è chiamato tipo grezzo - un tipo grezzo è un classe o interfaccia generica nome senza argomenti tipo. Ciò significa che non è possibile scoprire quale tipo di oggetto utilizza una classe generica al runtime .

sembra Questo anche come questo question che ha un pretty good answer as well.

Answer 3

Io non sono sicuro al 100% se questo funziona in tutti i casi (ha bisogno di almeno 1 Java.5):

import java.lang.reflect.Field; 
import java.lang.reflect.ParameterizedType; 
import java.lang.reflect.Type; 
import java.util.HashMap; 
import java.util.Map; 

public class Main 
{ 
    public class A 
    { 
    } 

    public class B extends A 
    {  
    } 


    public Map<A, B> map = new HashMap<Main.A, Main.B>(); 

    public static void main(String[] args) 
    { 

     try 
     { 
      Field field = Main.class.getField("map");   
      System.out.println("Field " + field.getName() + " is of type " + field.getType().getSimpleName()); 

      Type genericType = field.getGenericType(); 

      if(genericType instanceof ParameterizedType) 
      { 
       ParameterizedType type = (ParameterizedType) genericType;    
       Type[] typeArguments = type.getActualTypeArguments(); 

       for(Type typeArgument : typeArguments) 
       { 
        Class<?> classType = ((Class<?>)typeArgument);     
        System.out.println("Field " + field.getName() + " has a parameterized type of " + classType.getSimpleName()); 
       } 
      } 
     } 
     catch(Exception e) 
     { 
      e.printStackTrace(); 
     } 
    }  
} 

Questo stamperà:

mappa del campo è di tipo Map
mappa campo ha un tipo parametrico di una mappa dei campi
ha un tipo parametrico di B

Answer 4

Sono in grado di ottenere la classe del tipo generico in questo modo:

class MyList<T> { 
    Class<T> clazz = (Class<T>) DAOUtil.getTypeArguments(MyList.class, this.getClass()).get(0); 
} 

avete bisogno di due funzioni da questo file: http://code.google.com/p/hibernate-generic-dao/source/browse/trunk/dao/src/main/java/com/googlecode/genericdao/dao/DAOUtil.java

Per ulteriori spiegazioni: http://www.artima.com/weblogs/viewpost.jsp?thread=208860

Answer 5

mi piace la soluzione da

http://www.nautsch.net/2008/10/28/class-von-type-parameter-java-generics/

public class Dada<T> { 

    private Class<T> typeOfT; 

    @SuppressWarnings("unchecked") 
    public Dada() { 
     this.typeOfT = (Class<T>) 
       ((ParameterizedType)getClass() 
       .getGenericSuperclass()) 
       .getActualTypeArguments()[0]; 
    } 
...