java - 获取从非泛型类型类扩展的类的泛型类型

Question

我有一堂这样的课

public class RequestDataEditor<T> extends PropertyEditorSupport {
    @Override
    public void setAsText(String text) {

        MyData<T> value;

        try {
            //(ParameterizedType)getClass().getGenericSuperclass()

            value = JacksonUtil.parse(text, new TypeReference<MyData<T>>() {
            });
        } catch (Exception e) {
            value = null;
        }

        setValue(value);
    }
}

当我运行(ParameterizedType)getClass().getGenericSuperclass()时，期望为 T，但它是 PropertyEditorSupport，并且无法转换为 ParameterizedType；

如果我删除extends PropertyEditorSupport，那么我可以获得泛型类型。(事实证明是错误的，我在这里犯了一个错误。)

看来，我们不能使用(ParameterizedType)getClass().getGenericSuperclass()从父类没有泛型类型的类中获取泛型类型。

那么如何使用像RequestDataEditor这样的类来获取泛型类型呢？

not duplicate with the question ，我想知道当使用 (ParameterizedType)getClass().getGenericSuperclass() 与一个没有泛型类型父类(super class)的类时有什么不同。

Answer 1

When I run (ParameterizedType)getClass().getGenericSuperclass(), expect to be T, but it's PropertyEditorSupport, and can't be casted to ParameterizedType;

如果您想访问T又名类型参数，适当的反射方法是 Class.getTypeParameters .

// Test.java:
class Generic<T> {
}

class Main {

  public static void main(String[] args) {

     final Generic<Integer> gint1 = new Generic<Integer>();

     System.err.println("gint1's type-parameter: " 
                       + gint1.getClass().getTypeParameters()[0]);
  }
}

如果运行上面的代码，您会得到以下结果:

$ javac Test.java
$ java Main
gint1's type-parameter: T

请注意，类型参数未解析为 Integer，而是解析为 T因为此信息在运行时不可用。

如果访问此信息对您很重要，那么您有两个直接的选择。

A.该对象包含对实际类型类的引用:

class Generic<T> {

    public final Class<T> type;

    public Generic(Class<T> type) {
        this.type = type;
    }

    public Class<T> type() {
        return type;
    }
}

class Main {
    public static void main(String[] args) {

        final Generic<Integer> gint2 = new Generic<>(Integer.class);
        System.err.println("gint2's type-parameter: " + gint2.type().getSimpleName());
    }
}
// Output will be "gint2's type-parameter: Integer".

B.您创建一个子类，为该类型参数提供一个具体类:

import java.lang.reflect.*;

class Generic<T> {
}

class IntegerGeneric extends Generic<Integer> {
}

class Main {
    public static void main(String[] args) {

        final Generic<Integer> gint3 = new IntegerGeneric();
        final Generic<Double> gint4 = new Generic<Double>() {};
        System.err.println("gint3's type-parameter: "
            + ((ParameterizedType)gint3.getClass().getGenericSuperclass()).getActualTypeArguments()[0]);
        System.err.println("gint4's type-parameter: "
            + ((ParameterizedType)gint4.getClass().getGenericSuperclass()).getActualTypeArguments()[0]);
    }
}
// Output:
// gint3's type-parameter: class java.lang.Integer
// gint4's type-parameter: class java.lang.Double

注意 gint4 类不是 Generic<Double>但在匿名内部类中，由于{}而扩展了它遵循构造函数...这是完整 class DoubleGeneric ... 的替代方案声明。

在这两种选择中，A. 和 B.，A. 更可取，因为通常应避免依赖反射；除此之外，它更容易隐藏运行时错误，并且代码更难以维护。

I want to know what's the different when use (ParameterizedType)getClass().getGenericSuperclass() with a class has a none generic type super class.

如果您查找 Type文档中，此方法返回的引用的类，它表明它是 Java 语言中可用的所有对象/数据类型的“伞” super 接口(interface)，甚至包括基元......所以对于没有通用父类(super class)我想它会返回反射(reflect)该类型的子类...

一个快速实验表明，实际上它会返回一个“Class”对象，因此它相当于 getSuperclass()。

也许其他人可以对此提供更明智的观点，但我认为这可能有点命名不当......我认为 getSuperType() 或类似的东西会更合适。也许最初它只支持较旧的 Java 版本(1.5？)中的泛型，并最终扩展到涵盖其他数据类型，但这是我在没有研究其历史的情况下的疯狂猜测。