0

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

当参数化类型通过层次结构时，在Java中创建泛型类型的实例？

为了尝试从包含的类创建新的泛型，我尝试采用 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();
    }
}

请注意 Parameterized contains = new Parameterized(){};

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

4

2 回答 2

0

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

new Parameterized<E>(){};

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

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

new Parameterized<String>(){};

我试图适应 Steve B 创建匿名子类的方法：

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

于 2013-09-01T22:55:55.373 回答
0

只要 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;
于 2013-10-26T02:32:32.310 回答