Question

这是我的代码： 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;
    }
}

那么，我的代码有什么问题？

Answer 1

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

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);
    }

    // ...
}

Answer 2

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

要获得ParameterizedType，您应首先使用getGenericSuperclass。

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

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

应该返回String.class。

Answer 3

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

Answer 4

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

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

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

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

4 个答案: