# Per Reflection an die eigentlichen Typen eines Generic Typs ermitteln



## Thomas Darimont (31. August 2006)

Hallo!

Hier mal ein Beispiel wie man per Reflection an die eigentlichen Typen eines parameterisierbaren Typs heran kommen kann.
Die Information steht dann noch im .class File. Viel weiter kann man die Reflection nicht mehr treiben sobald der 
"eigentliche" Type eines parameterisierten Typs ein Parameter (T extends BlaFasel) ist kommt man nur noch an die TypeVariable heran aber nicht mehr (wegen dem Type erasure) an den im Code verwendeten Typ.


```
/**
 * 
 */
package de.tutorials;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;

/**
 * @author Thomas.Darimont
 *
 */
public class GenericTypeDetectionExample {

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception{
        Method createStringFactoryMethod = GenericTypeDetectionExample.class.getMethod("createStringFactory", new Class[0]);
        ParameterizedType parameterizedReturnType = (ParameterizedType)createStringFactoryMethod.getGenericReturnType();
        System.out.println(parameterizedReturnType.getActualTypeArguments()[0]);
    }

    static interface IFactory<TargetType>{
        TargetType create();
    }
    
    public IFactory<String> createStringFactory(){
        return new IFactory<String>(){
            public String create() {
                return "BLABLABLA";
            }
        };
    }
}
```

Ausgabe:

```
class java.lang.String
```

Gruß Tom


----------

