如何在运行时获取通用类型？

Question

如何在运行时获取通用类型？

12

这是我的代码： ExecutorImp继承了抽象执行器AbstractExecutor，该抽象执行器提取了其实现者（ExecutorImp是其中之一）相同的执行逻辑。当调用ExecutorImp的execute()方法时，它将调用其超类型中的方法，但是超类型（即AbstractExecutor）应该知道绑定到实现者的另一个类（在本例中为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;
    }
}

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

- hguser

也许这个答案可以帮助解决你的问题。https://dev59.com/1Ww15IYBdhLWcg3wbLHU#19454610 - Enrico Giurin

4个回答

6

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

为了获取ParameterizedType，你需要先使用getGenericSuperclass。 更新：但上述方法仅适用于当前对象派生自已经实例化泛型参数的泛型类，例如：

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

应该返回 String.class。

- fortran

6

为了准确起见：只有在类不是泛型类时，getGenericSuperclass()才会为您提供有意义的结果，因此：new LinkedList<String>().getClass().getGenericSuperclass() 对您来说不够用，但是：new LinkedList<String>(){}.getClass().getGenericSuperclass() 就可以了——注意到了区别吗？通过添加 {}，我创建了 LinkedList 的子类。 - iirekm

如果@iirekm是正确的，那么我想对象无法检测它是如何反射声明的，但可以从“外部”完成（例如使用Field.getGenericType()）... - fortran

2

我认为您无法在运行时获取泛型类型。泛型类型是应用于编译时的限制。据我所记，运行时泛型集合和没有泛型类型的集合之间没有区别。

- Seitaridis

并不完全正确：请阅读“fortran”的解决方案以及我的评论。 - iirekm

2

呵呵，我也曾经这样想过……泛型擦除意味着在编译时可以忽略泛型限制，因为运行两个实例的字节码是相同的，但是关于实例如何声明的信息被保留下来。 - fortran

1

通常解决这个问题的方法是稍微更改代码。在基类上定义一个接受Class<E>参数的构造函数，并将此参数分配给内部字段。

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

这样，您就可以在不过多增加子类客户端负担的情况下知道参数的类。

- oiavorskyi

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- BalusC · Accepted Answer

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

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

    // ...
}