如何在运行时获取泛型？

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

    // ...
}