Tony Morris sez:

... Not *all* information is lost to type erasure, and for the

The details are related to the difference between "class" and "object"
(hint: "runtime" in Adam's post is a dead giveaway) and if you don't
remember them you probably should read an OO 101 text book before you
try to program anything.

HTH
Dima

No problem, as long as the genericity is defined in the class. Example:

import java.util.*;
import java.lang.reflect.*;

public class ReflectMethodGenerics {

   public static void main(String[] args) throws Exception {

     ReflectMethodGenerics rg = new ReflectMethodGenerics();
       Class c = rg.getClass();
       Method m = c.getMethod("GenericMethod");
       Type  t = m.getGenericReturnType();

       Class x = extractType(t);

       System.out.println(x);
   }

   public ArrayList<String> GenericMethod() {
       ArrayList<String> s = new ArrayList<String>();
       return s;
   }

   private static Class extractType(Type t) {
       if (t != null && t instanceof ParameterizedType) {
           ParameterizedType pt = (ParameterizedType) t;
           Type[] genTypes = pt.getActualTypeArguments();

           if (genTypes.length == 1 && genTypes[0] instanceof Class) {
               return (Class) genTypes[0];
           } else if (genTypes.length == 2 && genTypes[1] instanceof Class)
{
               // TODO we might want to store the index type at some point
               return (Class) genTypes[1];
           }
       }
       return null;
   }
}

-------------------------
However, if the method's return type isn't declared as the generic type, you
can't get the parameterized type, as this also is valid...

   public ArrayList GenericMethod() {
       ArrayList<String> s = new ArrayList<String>();
       return s;
   }

// Bjorn A

...

Have you tried using getGenericReturnType instead of getReturnType? This
program, when run with no command line arguments, prints
"java.util.ArrayList<java.lang.String>". When run with an argument, it
prints "class java.util.ArrayList".

import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.ArrayList;

public class GenericTest {

  public static void main(String[] args) {
    Object o;
    if (args.length > 0) {
      o = new C1();
    } else {
      o = new C2();
    }
    Class c = o.getClass();
    try {
      Method m = c.getMethod("myMethod", new Class[0]);
      Type t = m.getGenericReturnType();
      System.out.println(t);
    } catch (SecurityException e) {
      e.printStackTrace();
    } catch (NoSuchMethodException e) {
      e.printStackTrace();
    }
  }
}

class C1 {
  public ArrayList myMethod() {
    return new ArrayList();
  }
}

class C2 {
  public ArrayList<String> myMethod() {
    return new ArrayList<String>();
  }
}

Patricia