假设您有以下抽象java类:
public abstract class AbstractRequestHandler<I,O> {
I input;
O output;
}
以及以下子类层次结构:
public abstract class AbstractUserRequestHandler<I extends User,O> extends AbstractRequestHandler<I,O>{...}
public abstract class AbstractUniversityRequestHandler<I extends UniversityUser> extends AbstractUserRequestHandler<I,String>{...}
public class StudentRequestHandler extends AbstractUniversityRequestHandler<Student>{...}
public class TeacherRequestHandler extends AbstractUniversityRequestHandler<Teacher>{...}
假设您需要在超类上的给定点使用泛型类型,例如,为了在构造函数上使用gson库将请求json反序列化到特定的请求对象,如下所示:
public AbstractRequestHandler(final String inputJson) {
input = new Gson().fromJson(inputJson,typeOfI);
}
您需要变量“typeOfI”中的泛型I类型
是否有一个全局解决方案,允许获得由尊重以下约束的具体子类指定的泛型类型?
因此,如果您想定义一个新的具体子类,为泛型指定一个新值,您可以编写以下具体类,例如:
public class StudentRequestHandler extends AbstractUniversityRequestHandler<Student>{
public StudentRequestHandler(String inputJson) {
super(inputJson);
}
}
我找到了以下解决方案,但它们不尊重所要求的解决方案约束。
解决方案可以是在超类上定义一个抽象方法,如下所示
protected abstract Type getRequestType();
然后在定义泛型的每个具体子类上实现它:
public class StudentRequestHandler extends AbstractUniversityRequestHandler<Student>{
public StudentRequestHandler(String inputJson) {
super(inputJson);
}
@Override
protected Type getRequestType() {
return Student.class;
}
}
然后可以在目标超类的构造函数上使用getRequestType()方法:
public AbstractRequestHandler(final String inputJson) {
request = new Gson().fromJson(inputJson,getRequestType());
}
但是,即使不管子类的层次结构如何(尊重约束n°1),开发人员也应该在每个具体的子类上手动实现一个抽象方法。
如果层次结构是简单的,只有从目标超类扩展的直接子类,例如:
public class TeacherRequestHandler extends AbstractRequestHandler<Teacher,String>{...}
@nakus(https://stackoverflow.com/users/306602/naikus)在以下stackoverflowhtml" target="_blank">线程上提出了一个工作解决方案:在抽象超类中使用子类的泛型类型?
然而,如果具体类不是定义泛型的超类的直接子类(如在这个问题上提出的例子),这就不起作用了。
我认为一个可行的解决方案是扩展@naikus提出的方案。它只需要在构造函数的层次结构中上升。
import java.lang.reflect.ParameterizedType;
public abstract class AbstractRequestHandler<I,O> {
protected I input;
protected O output;
protected Class<I> inputClass;
protected Class<O> outputClass;
protected AbstractRequestHandler() {
Class<?> clazz = getClass();
while (!clazz.getSuperclass().equals(AbstractRequestHandler.class)) {
clazz = clazz.getSuperclass();
}
ParameterizedType genericSuperclass = (ParameterizedType) clazz.getGenericSuperclass();
this.inputClass = (Class<I>) genericSuperclass.getActualTypeArguments()[0];
this.outputClass = (Class<O>) genericSuperclass.getActualTypeArguments()[1];
}
}
答案是:Java不支持具体化泛型,请参阅2004年的此功能请求,其中包含大量重复项。另请参见:
因此,除非您想切换到静态编程语言,否则您无能为力,因为Java中的泛型类型信息仅对编译器可用,而不是在运行时(实现泛型)。
如果你不喜欢这个答案,我很抱歉,但截至2020年初Java13,它仍然是正确的。
编辑:在阅读了您的答案并测试了许多其他可能的情况后,我决定编辑您的代码并重新编写,以支持所有其他可能的边缘情况,包括跟踪深入嵌套在其他泛型类型中的泛型。
不幸的是,为了支持所有的情况,我们需要比你提供的代码多很多,泛型非常棘手,比如考虑这样的类:
private class SomeClass<A, B, C, D, E, F> {}
private class SomeConfusingClass<A> extends SomeClass<List<Void>[], List<? extends A>[], List<? extends A[][][]>[][][], List<? extends String[]>[], Map<List<? extends A[]>, A[][]>[], A> {}
private class TestClass extends SomeConfusingClass<Void> {}
为了开始这样做,我们需要有自己的java泛型类型实现,以便以后能够构造List这样的类型
private static class ResolvedGenericArrayType implements GenericArrayType {
private final Type genericComponentType;
ResolvedGenericArrayType(Type genericComponentType) {
this.genericComponentType = genericComponentType;
}
@Override
public Type getGenericComponentType() {
return genericComponentType;
}
public String toString() {
return getGenericComponentType().toString() + "[]";
}
@Override
public boolean equals(Object o) {
if (o instanceof GenericArrayType) {
GenericArrayType that = (GenericArrayType) o;
return Objects.equals(genericComponentType, that.getGenericComponentType());
} else
return false;
}
@Override
public int hashCode() {
return Objects.hashCode(genericComponentType);
}
}
private static class ResolvedParameterizedType implements ParameterizedType {
private final Type[] actualTypeArguments;
private final Class<?> rawType;
private final Type ownerType;
private ResolvedParameterizedType(Type rawType, Type[] actualTypeArguments, Type ownerType) {
this.actualTypeArguments = actualTypeArguments;
this.rawType = (Class<?>) rawType;
this.ownerType = (ownerType != null) ? ownerType : this.rawType.getDeclaringClass();
}
public Type[] getActualTypeArguments() {
return actualTypeArguments.clone();
}
public Class<?> getRawType() {
return rawType;
}
public Type getOwnerType() {
return ownerType;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof ParameterizedType)) {
return false;
}
ParameterizedType that = (ParameterizedType) o;
if (this == that)
return true;
Type thatOwner = that.getOwnerType();
Type thatRawType = that.getRawType();
return Objects.equals(ownerType, thatOwner) && Objects.equals(rawType, thatRawType) &&
Arrays.equals(actualTypeArguments, that.getActualTypeArguments());
}
@Override
public int hashCode() {
return Arrays.hashCode(actualTypeArguments) ^
Objects.hashCode(ownerType) ^
Objects.hashCode(rawType);
}
public String toString() {
StringBuilder sb = new StringBuilder();
if (ownerType != null) {
sb.append(ownerType.getTypeName());
sb.append("$");
if (ownerType instanceof ResolvedParameterizedType) {
sb.append(rawType.getName().replace(((ResolvedParameterizedType) ownerType).rawType.getName() + "$", ""));
} else
sb.append(rawType.getSimpleName());
} else
sb.append(rawType.getName());
if (actualTypeArguments != null) {
StringJoiner sj = new StringJoiner(", ", "<", ">");
sj.setEmptyValue("");
for (Type t : actualTypeArguments) {
sj.add(t.getTypeName());
}
sb.append(sj.toString());
}
return sb.toString();
}
}
private static class ResolvedWildcardType implements WildcardType {
private final Type[] upperBounds;
private final Type[] lowerBounds;
public ResolvedWildcardType(Type[] upperBounds, Type[] lowerBounds) {
this.upperBounds = upperBounds;
this.lowerBounds = lowerBounds;
}
public Type[] getUpperBounds() {
return upperBounds.clone();
}
public Type[] getLowerBounds() {
return lowerBounds.clone();
}
public String toString() {
Type[] lowerBounds = getLowerBounds();
Type[] bounds = lowerBounds;
StringBuilder sb = new StringBuilder();
if (lowerBounds.length > 0)
sb.append("? super ");
else {
Type[] upperBounds = getUpperBounds();
if (upperBounds.length > 0 && !upperBounds[0].equals(Object.class)) {
bounds = upperBounds;
sb.append("? extends ");
} else
return "?";
}
StringJoiner sj = new StringJoiner(" & ");
for (Type bound : bounds) {
sj.add(bound.getTypeName());
}
sb.append(sj.toString());
return sb.toString();
}
@Override
public boolean equals(Object o) {
if (o instanceof WildcardType) {
WildcardType that = (WildcardType) o;
return Arrays.equals(this.getLowerBounds(), that.getLowerBounds()) && Arrays.equals(this.getUpperBounds(), that.getUpperBounds());
} else
return false;
}
@Override
public int hashCode() {
Type[] lowerBounds = getLowerBounds();
Type[] upperBounds = getUpperBounds();
return Arrays.hashCode(lowerBounds) ^ Arrays.hashCode(upperBounds);
}
}
你基本上可以从JDK复制它们,然后做一些清理。
我们需要的下一个实用程序是一个函数,在最后验证我们是否做了所有正确的事情,比如我们不想返回
Map
private static boolean isDefined(Type type) {
if (type instanceof Class) {
return true;
}
if (type instanceof GenericArrayType) {
return isDefined(((GenericArrayType) type).getGenericComponentType());
}
if (type instanceof WildcardType) {
for (Type lowerBound : ((WildcardType) type).getLowerBounds()) {
if (!isDefined(lowerBound)) {
return false;
}
}
for (Type upperBound : ((WildcardType) type).getUpperBounds()) {
if (!isDefined(upperBound)) {
return false;
}
}
return true;
}
if (!(type instanceof ParameterizedType)) {
return false;
}
for (Type typeArgument : ((ParameterizedType) type).getActualTypeArguments()) {
if (!isDefined(typeArgument)) {
return false;
}
}
return true;
}
简单的递归函数可以帮我们做到这一点。我们只需检查每个可能的泛型类型,并检查它的每个成员是否也被定义,除非我们会找到一些隐藏的
TypeVariable
,否则我们就没事了
主功能可以与代码中的功能保持一致,我们只会在最后编辑该检查以使用我们的新功能:
public static Type getParameterizedType(Class<?> klass, Class<?> rootClass, int paramTypeNumber) throws GenericsException {
int targetClassParametersNumber = rootClass.getTypeParameters().length;
if (targetClassParametersNumber == 0) {
throw new GenericsException(String.format("Target class [%s] has no parameters type", rootClass.getName()));
} else if (targetClassParametersNumber - 1 < paramTypeNumber)
throw new GenericsException(String.format("Target class [%s] has parameters type which index start from [0] to [%s]. You requested instead parameter with index [%s]", rootClass, paramTypeNumber - 1, targetClassParametersNumber));
Type type = analyzeParameterizedTypes(klass, klass, rootClass, paramTypeNumber, null);
if (!isDefined(type))
throw new GenericsException(String.format("Parameter [%s] with index [%d] defined on class [%s] has not been valued yet on child class [%s]", type, paramTypeNumber, rootClass.getName(), klass.getName()));
return type;
}
现在让我们来处理我们的主要问题
public static Type analyzeParameterizedTypes(final Class<?> klass, final Class<?> targetClass, final Class<?> rootClass, final int paramTypeNumber, Map<Integer, Type> childClassTypes) throws GenericsException {
函数中,begging保持不变,我们将所有
TypeVariable
收集到简单映射中,保留上一个类的上一个循环中已经收集到的信息。
Type superclassType = klass.getGenericSuperclass();
Map<TypeVariable<?>, Type> currentClassTypes = new HashMap<>();
int z = 0;
if (childClassTypes != null) {
for (TypeVariable<?> variable : klass.getTypeParameters()) {
currentClassTypes.put(variable, childClassTypes.get(z));
z++;
}
}
然后我们有循环收集和提炼类型参数:
Map<Integer, Type> superClassesTypes = new HashMap<>();
if (superclassType instanceof ParameterizedType) {
int i = 0;
for (final Type argType : ((ParameterizedType) superclassType).getActualTypeArguments()) {
if (argType instanceof TypeVariable) {
superClassesTypes.put(i, currentClassTypes.containsKey(argType) ? currentClassTypes.get(argType) : argType);
} else {
superClassesTypes.put(i, refineType(klass, argType, currentClassTypesByName));
}
i++;
}
}
每个类型参数有2条路径,如果它是类型变量,我们只是继续跟踪它,如果它是其他任何东西,我们试图从任何可能的
Type变量
引用中“细化”它。这是这段代码最复杂的过程,这就是为什么我们需要上面所有这些类。
我们从这个简单的递归调度方法开始,它处理所有可能的类型:
private static Type refineType(Type type, Map<TypeVariable<?>, Type> typeVariablesMap) throws GenericsException {
if (type instanceof Class) {
return type;
}
if (type instanceof GenericArrayType) {
return refineArrayType((GenericArrayType) type, typeVariablesMap);
}
if (type instanceof ParameterizedType) {
return refineParameterizedType((ParameterizedType) type, typeVariablesMap);
}
if (type instanceof WildcardType) {
return refineWildcardType((WildcardType) type, typeVariablesMap);
}
if (type instanceof TypeVariable) {
return typeVariablesMap.get(type);
}
throw new GenericsException("Unsolvable generic type: " + type);
}
以及在类型数组上运行它的小实用方法:
private static Type[] refineTypes(Type[] types, Map<TypeVariable<?>, Type> typeVariablesMap) throws GenericsException {
Type[] refinedTypes = new Type[types.length];
for (int i = 0; i < types.length; i++) {
refinedTypes[i] = refineType(types[i], typeVariablesMap);
}
return refinedTypes;
}
每个类型都有自己的函数,或者如果它的
TypeVariable
,我们只从映射中获取一个解析的。请注意,这可能会返回null,我在这里没有处理它。这可以在以后改进。对于类,我们不需要做任何事情,所以我们可以直接返回类本身。
对于
GenericArrayType
,我们需要首先找出这样的数组可能有多少维(这也可以通过我们的refine方法中的递归来处理,但在我看来,这更难调试):
private static int getArrayDimensions(GenericArrayType genericArrayType) {
int levels = 1;
GenericArrayType currentArrayLevel = genericArrayType;
while (currentArrayLevel.getGenericComponentType() instanceof GenericArrayType) {
currentArrayLevel = (GenericArrayType) currentArrayLevel.getGenericComponentType();
levels += 1;
}
return levels;
}
然后我们要提取嵌套组件类型的数组,所以对于
List
private static Type getArrayNestedComponentType(GenericArrayType genericArrayType) {
GenericArrayType currentArrayLevel = genericArrayType;
while (currentArrayLevel.getGenericComponentType() instanceof GenericArrayType) {
currentArrayLevel = (GenericArrayType) currentArrayLevel.getGenericComponentType();
}
return currentArrayLevel.getGenericComponentType();
}
然后我们需要改进这种类型,所以我们的
List
Type arrayComponentType = refineType(getArrayNestedComponentType(genericArrayType), typeVariablesMap);
并使用改进的类型重建我们的泛型结构,因此我们创建了
列表
private static Type buildArrayType(Type componentType, int levels) throws GenericsException {
if (componentType instanceof Class) {
return Array.newInstance(((Class<?>) componentType), new int[levels]).getClass();
} else if (componentType instanceof ParameterizedType) {
GenericArrayType genericArrayType = new ResolvedGenericArrayType(componentType);
for (int i = 1; i < levels; i++) {
genericArrayType = new ResolvedGenericArrayType(genericArrayType);
}
return genericArrayType;
} else {
throw new GenericsException("Array can't be of generic type");
}
}
整个函数如下所示:
private static Type refineArrayType( GenericArrayType genericArrayType, Map<TypeVariable<?>, Type> typeVariablesMap) throws GenericsException {
int levels = getArrayDimensions(genericArrayType);
Type arrayComponentType = refineType(getArrayNestedComponentType(genericArrayType), typeVariablesMap);
return buildArrayType(arrayComponentType, levels);
}
对于
parameteredType
要简单得多,我们只需优化类型参数,并使用这些优化的参数创建新的parameteredType
实例:
private static Type refineParameterizedType(ParameterizedType parameterizedType, Map<TypeVariable<?>, Type> typeVariablesMap) throws GenericsException {
Type[] refinedTypeArguments = refineTypes(parameterizedType.getActualTypeArguments(), typeVariablesMap);
return new ResolvedParameterizedType(parameterizedType.getRawType(), refinedTypeArguments, parameterizedType.getOwnerType());
}
同样适用于
通配符类型
:
private static Type refineWildcardType(WildcardType wildcardType, Map<TypeVariable<?>, Type> typeVariablesMap) throws GenericsException {
Type[] refinedUpperBounds = refineTypes(wildcardType.getUpperBounds(), typeVariablesMap);
Type[] refinedLowerBounds = refineTypes(wildcardType.getLowerBounds(), typeVariablesMap);
return new ResolvedWildcardType(refinedUpperBounds, refinedLowerBounds);
}
这就给我们留下了一个完整的分析函数,如下所示:
public static Type analyzeParameterizedTypes(final Class<?> klass, final Class<?> targetClass, final Class<?> rootClass, final int paramTypeNumber, Map<Integer, Type> childClassTypes) throws GenericsException {
Type superclassType = klass.getGenericSuperclass();
Map<TypeVariable<?>, Type> currentClassTypes = new HashMap<>();
int z = 0;
if (childClassTypes != null) {
for (TypeVariable<?> variable : klass.getTypeParameters()) {
currentClassTypes.put(variable, childClassTypes.get(z));
z++;
}
}
Map<Integer, Type> superClassesTypes = new HashMap<>();
if (superclassType instanceof ParameterizedType) {
int i = 0;
for (final Type argType : ((ParameterizedType) superclassType).getActualTypeArguments()) {
if (argType instanceof TypeVariable) {
superClassesTypes.put(i, currentClassTypes.getOrDefault(argType, argType));
} else {
superClassesTypes.put(i, refineType(argType, currentClassTypes));
}
i++;
}
}
if (klass != rootClass) {
final Class<?> superClass = klass.getSuperclass();
if (superClass == null)
throw new GenericsException(String.format("Class [%s] not found on class parent hierarchy [%s]", rootClass, targetClass));
return analyzeParameterizedTypes(superClass, targetClass, rootClass, paramTypeNumber, superClassesTypes);
}
return childClassTypes.get(paramTypeNumber);
}
用法示例:
private class SomeClass<A, B, C, D, E, F> {}
private class SomeConfusingClass<A> extends SomeClass<List<Void>[], List<? extends A>[], List<? extends A[][][]>[][][], List<? extends String[]>[], Map<List<? extends A[]>, A[][]>[], A> {}
private class TestClass extends SomeConfusingClass<Void> {}
public static void main(String[] args) throws Exception {
System.out.println(GenericsUtils.getParameterizedType(TestClass.class, SomeClass.class, 0));
System.out.println(GenericsUtils.getParameterizedType(TestClass.class, SomeClass.class, 1));
System.out.println(GenericsUtils.getParameterizedType(TestClass.class, SomeClass.class, 2));
System.out.println(GenericsUtils.getParameterizedType(TestClass.class, SomeClass.class, 3));
System.out.println(GenericsUtils.getParameterizedType(TestClass.class, SomeClass.class, 4));
System.out.println(GenericsUtils.getParameterizedType(TestClass.class, SomeClass.class, 5));
}
和结果:
java.util.List<java.lang.Void>[]
java.util.List<? extends java.lang.Void>[]
java.util.List<? extends java.lang.Void[][][]>[][][]
java.util.List<? extends java.lang.String[]>[]
java.util.Map<java.util.List<? extends java.lang.Void[]>, java.lang.Void[][]>[]
class java.lang.Void
完整的测试代码可以在这里找到:https://gist.github.com/GotoFinal/33b9e282f270dbfe61907aa830c27587或者在这里:https://github.com/GotoFinal/generics-utils/tree/edge-cases-1
基于OP原始答案代码,但涵盖了大多数边缘案例。
“绑定不匹配:Team类型不是league类型 的有界参数 >的有效替代品。”
我试图在Scala中返回抽象泛型类的子类,但它无法编译。我得到A类型的表达式不符合预期的B类型。这是我使用的代码: 创建()的签名应该是什么? 谢谢
下面是解释我的情况的基本框架代码。 这是超级抽象类: 这是超级抽象类的一个子类:(注意,我删除了其他函数,比如构造函数和方法,以缩短文章的篇幅 我想在抽象类中使用这种公共无效支付(int金额)方法;然而,超级抽象类Person不会接受支付(付款),因为该方法不在范围内。如何使这个工作? 谢谢~
问题内容: 我有一个像这样的课程: 但是编译器说:。 我如何获得的课程? 问题答案: 绝对有可能将其提取出来,因为它不是在运行时定义的,而是在编译时由定义的。 这是一个启动示例,您可以如何在抽象类的构造函数中提取所需的泛型超类型,同时考虑子类的层次结构(以及在无需显式提供类型的情况下将其应用于泛型方法的实际用例)):
在我的Spring Boot应用程序中,我尝试实现模板方法,在我的具体类中,我尝试使用泛型,如下所示: 模板界面:不确定我是否需要使用它? 模板抽象类: 混凝土等级: 我在dto中得到“无法解析‘T’中的方法‘getName’”。getName()行输入AbstractPDFGenerator。 我的问题是: 1.为了解决这个问题,我想从继承和的基类扩展T。但是,我不想从基类继承它们,因为它们没有
我通过学校为一项任务提供的简报创建了一个飞机座位预订系统。我遇到了一个我无法解决的主要问题。 摘要说明抽象类必须有一个抽象方法和大约4个公共方法。在抽象类的两个子类中,我们都必须初始化对象数组(所有普通的座位)。然而,一旦它们被初始化,我不知道如何将它们发送回抽象类(该类有一个检查未预订的飞机座位的方法,这就是我需要初始化的座位对象的地方) ArrayIndexOutOfBounds在一个应该在边