Generics hierarchy in extending interfaces

Question

Let's say I have an interface like this:
package source;
import java.util.List;
public interface ITest <GTest extends List> {
    public void setList(GTest list);
}I extend that interface to have a new one whose generic is an implementation of the generic of the original interface:
package source;
import java.util.ArrayList;
public interface ITestEx extends ITest<ArrayList> {
}Then I write a class which inspects the extended interface to enumerate its methods with their parameters:
package source;
import java.lang.reflect.Method;
public class Test {
    public static void main(String[] args) {
        Method methods[] = ITestEx.class.getMethods();
        for (int nMethod = 0; nMethod < methods.length; nMethod++) {
            System.out.println("\nMethod #" + nMethod + ": " + methods[nMethod].getName());
            Class<?>[] parameterTypes = methods[nMethod].getParameterTypes();
            for (int nParameterType = 0; nParameterType < parameterTypes.length; nParameterType++) {
                System.out.println("Parameter type #" + nParameterType + ": " + parameterTypes[nParameterType].getName());
}The output is:
Method #0: setList
Parameter type #0: java.util.List
That is, the argument of the setList(GTest) method is retrieved as List, which is the type GTest was declared to be in the base interface (ITest), even though getMethods() was called on its subinterface (ITestEx), which declares the generic as ArrayList.
Is it possible to use reflection in a way that in this case would retrieve the argument of setList(GTest) as ArrayList ?
P.S. We have been pointed to http://www.ibm.com/developerworks/library/j-cwt11085.html , but we couldn't understand whether it might help.
Edited by: SantiBailors on Sep 19, 2007 3:25 PM

Answer 1

Hi, I've altered your code by adding a helper method getTypes that maps formal type arguments to actual types. Now it prints the "real" type names. HTH
public static void main(String[] args) {
          Map<TypeVariable<?>, Type> types = getTypes(ITestEx.class, ITest.class);
          Method methods[] = ITestEx.class.getMethods();
          for (int nMethod = 0; nMethod < methods.length; nMethod++) {
               System.out.println("\nMethod #" + nMethod + ": " + methods[nMethod].getName());
               Type[] parameterTypes = methods[nMethod].getGenericParameterTypes();
               for (int nParameterType = 0; nParameterType < parameterTypes.length; nParameterType++) {
                    if (types.containsKey(parameterTypes[nParameterType]))
                         System.out.println("Parameter type #" + nParameterType + ": "
                                   + types.get(parameterTypes[nParameterType]));
                    else
                         System.out.println("Parameter type #" + nParameterType + ": " + parameterTypes[nParameterType]);
     private static <T> Map<TypeVariable<?>, Type> getTypes(Class<? extends T> cl, Class<T> genericInterface) {
          Map<TypeVariable<?>, Type> typeMapping = new HashMap<TypeVariable<?>, Type>();
          for (Type t : cl.getGenericInterfaces()) {
               if (t instanceof ParameterizedType) {
                    ParameterizedType pt = (ParameterizedType)t;
                    if (pt.getRawType().equals(genericInterface)) {
                         for (int i = 0; i < genericInterface.getTypeParameters().length; ++i)
                              typeMapping.put(genericInterface.getTypeParameters(), pt.getActualTypeArguments()[i]);
                         break;
          return typeMapping;
Edited by: McNepp on Sep 20, 2007 12:14 PM