Question

这是我的问题的后续行动：

Create instance of generic type in Java when parameterized type passes through hierarchies?

为了尝试从包含的类创建新泛型，我尝试调整Steve B创建匿名子类的方法：

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class ParameterizedTypeEg {
    ParameterizedTypeEg () {
        ContainsParameterized<String> containString = new ContainsParameterized<String>();
    }
    public class Parameterized<E> {
        Parameterized () {
        }
        public Class<E> getTypeParameterClass() {
            Type type = getClass().getGenericSuperclass();
            ParameterizedType paramType = (ParameterizedType) type;
            return (Class<E>) paramType.getActualTypeArguments()[0];
        }
        public Constructor<E> getTypeParameterConstructor() {
            Constructor<E> constructor = null;
            try {
                constructor = getTypeParameterClass().getConstructor(QueriedColor.class);
            } catch (NoSuchMethodException e) { System.err.println(e); }
            return constructor;
        }           
    }
    class ContainsParameterized<E> {
        ContainsParameterized () {
            Parameterized<E> contained = new Parameterized<E>(){};
            try {
                E element = contained.getTypeParameterConstructor().newInstance();
            }
            catch (InstantiationException e) { System.err.println(e); }
            catch (IllegalAccessException e) { System.err.println(e); }
            catch (InvocationTargetException e) { System.err.println(e); }
        }
    }
    public static void main(String[] args) {
        new ParameterizedTypeEg();
    }
}

请注意该行参数化包含= new Parameterized（）{};

这里我试图创建匿名子类，正如Steve B在另一篇文章中所建议的那样。但是，我在getTypeParameterClass（）方法中得到了ClassCastException。这与我的其他帖子中的异常类型相同。这让我认为我可以使用与Steve B针对该问题建议的相同解决方案。

Answer 1

匿名类必须在其声明中使用硬编码的实际类型参数才能使其正常工作。

new Parameterized<E>(){};

不起作用。你只是硬编码“E”（一个类型变量）。因此，当您使用反射查看元数据时，您看到的是“E”（类型变量）。

您必须创建一个子类，该子类在编译时使用实际类作为类型参数对其超类进行硬编码：

new Parameterized<String>(){};

我试图改编Steve B创建匿名子类的方法：

你错过了这一点。关键不是要创建一个子类。关键是要创建一个子类，其类型参数的实际类在超类中进行了硬编码。

Answer 2

只要在某个类型定义中对E进行参数化，您尝试执行的操作就可以正常工作。例如：

Parameterized<E> pe = new Parameterized<E>();

这不允许您解析E，因为它不是类型定义的一部分。另一方面，这个：

class StringE extends Parameterized<String> {}

或者这个：

Parameterized<String> ps = new Parameterized<String>(){};

将起作用，因为我们将E的值指定为类型定义的一部分。要解析E的值，您可以使用TypeTools：

Class<?> stringType = TypeResolver.resolveRawArgument(Parameterized.class, ps.getClass());
assert stringType == String.class;

在包含参数化类型时，在Java中创建泛型类型的实例？

2 个答案: