如何在运行时获取泛型类型?

时间:2010-10-15 10:27:55

标签: java generics reflection

这是我的代码: ExecutorImp扩展了AbstractExecutor,它提取了与其实现者相同的执行逻辑(ExecutorImp就是一个例子),当调用ExecutorImp的execute()方法时,它将调用其超类型中的方法,但是超类型(AbstractExcutor)应该知道另一个类绑定到实现者(在示例中,它是User类):

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;

abstract class AbstractExecutor<E> {
    public void execute() throws Exception {
        ArrayList<E> list = new ArrayList<E>();
        // here I want to get the real type of 'E'
        Class cl = this.getClass().getTypeParameters()[0].getGenericDeclaration().getClass();
        Object o = cl.getConstructor(String.class).newInstance("Gate");
        list.add((E) o);
        System.out.println(format(list));
    }
    public abstract String format(ArrayList<E> list);
    public abstract String getType();
}

public class ExectorImp<E> extends AbstractExecutor<User> {
    @Override
    public String getType() {
        return "user";
    }
    @Override
    public String format(ArrayList<User> list) {
        StringBuffer sb = new StringBuffer();
        for (User u : list) {
            sb.append(u.toString() + " ");
        }
        return sb.toString();
    }
    public static void main(String[] args) throws Exception {
        new ExectorImp().execute();
    }
}
class User {
    String name;
    public User(String name) {
        this.name = name;
    }
}

那么,我的代码有什么问题?

4 个答案:

答案 0 :(得分:14)

这里有一些混乱。由于类型擦除,您无法从运行时参数化类型获取类型信息,如:

Class<E> cls = E.getClass(); // Error.
E e = new E(); // Error.

但是,您可以通过ParameterizedType#getActualTypeArguments()从类,字段和方法声明中获取编译时参数化类型信息。

abstract class AbstractExecutor<E> {

    public void execute() throws Exception {
        List<E> list = new ArrayList<E>();
        Class<E> cls = (Class<E>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
        E e = cls.getConstructor(String.class).newInstance("Gate");
        list.add(e);
        System.out.println(format(list));
    }

    // ...
}

更新:关于是否建议这样做,虽然这会起作用,但只要发生类声明中的微小更改,这就会对运行时问题敏感。您作为开发人员应该正确记录它。作为一种完全不同的替代方案,您可以利用多态性。

abstract class AbstractExecutor<E> {

    public void execute() throws Exception {
        List<E> list = new ArrayList<E>();
        E e = create("Gate");
        list.add(e);
        System.out.println(format(list));
    }

    public abstract E create(String name);

    // ...
}

并相应地实施UserExecutor

class UserExecutor extends AbstractExecutor<User> {

    @Override
    public User create(String name) {
        return new User(name);
    }

    // ...
}

答案 1 :(得分:6)

我认为你应该使用getActualTypeParameters;因为getTypeParameters并未引用当前实例化中代替E的内容,而是引用E本身(以描述它是如何限制的等等)。

要获得ParameterizedType,您应首先使用getGenericSuperclass

更新:但上述内容仅在当前对象派生自实例化通用类的泛型类时才有效,如:

class StringList extends ArrayList<String> {
    public Type whatsMyGenericType() {
        return ((ParameterizedType)getGenericSuperClass()).getActualTypeParameters()[0];
    }
}

应该返回String.class

答案 2 :(得分:2)

我认为你不能在运行时获得泛型类型。泛型类型是在编译时应用的限制。我记得在运行时,泛型集合和没有泛型类型的集合之间没有区别。

答案 3 :(得分:1)

修复问题的常用方法是稍微更改代码。在接受Class<E>参数的基类上定义构造函数。将此参数分配给内部字段。

在子类上定义没有参数的构造函数,并从那里调用super(User.class)

通过这种方式,您将了解参数类,而不会对子类的客户端造成太大的负担。