问如何通过反射获取继承的参数化字段类？

EN

Class<?> cls = A.class; // using `A` as an example
Class<?> sup = cls.getSuperclass();

 // TypeVariables of `B`
TypeVariable<?>[] tv = sup.getTypeParameters();
 // Concrete types used to extend with in `A`
Type[] actual = ((ParameterizedType) cls.getGenericSuperclass()).getActualTypeArguments();

Map<TypeVariable<?>, Type> mappings // map one to the other
    = IntStream.range(0, tv.length)
        .boxed()
        .collect(Collectors.toMap(i -> tv[i], i -> actual[i]));


for(Field f : sup.getDeclaredFields()) {
    Type t1 = f.getGenericType();
    System.out.println(t1); // prints `D<T>`
    Type t2 = concretify(t1, mappings);
    System.out.println(t2); // prints `D<C>`
}

public static Type concretify(Type from, Map<TypeVariable<?>, Type> mappings) {
    if(from instanceof ParameterizedType) {
        ParameterizedType pt = (ParameterizedType) from;

        Type[] ts = pt.getActualTypeArguments();
        Type[] result = new Type[ts.length];
        for (int i = 0; i < ts.length; i++) {
            result[i] = mappings.getOrDefault(ts[i], ts[i]);
        }

        return new ParameterizedType() { // some ParameterizedType implementation

            @Override
            public Type getRawType() {
                return pt.getRawType();
            }

            @Override
            public Type getOwnerType() {
                return pt.getOwnerType();
            }

            @Override
            public Type[] getActualTypeArguments() {
                return result;
            }

            @Override
            public String toString() {
                return String.format("%s<%s>", getRawType().getTypeName(),
                    Arrays.stream(getActualTypeArguments())
                        .map(Type::getTypeName)
                        .collect(Collectors.joining(",")));
            }
        };
    }
    return from;
}