Java筑基——反射（2）：泛型周边信息获取

最新推荐文章于 2023-11-20 16:48:11 发布
原创 最新推荐文章于 2023-11-20 16:48:11 发布 · 832 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#java #反射 #泛型
本文详细介绍了Java中泛型类的周边信息获取方法，包括泛型超类、泛型接口及相关信息的获取，同时深入探讨了Type体系，如ParameterizedType、TypeVariable、GenericArrayType和WildcardType的使用，有助于读者深入理解Java反射机制。

相关文章：

目录

1. 前言

本文主要介绍获取泛型超类和泛型接口的相关信息；Type 的分类以及在泛型超类和泛型接口中的使用案例。
这部分内容不是很好理解，需要好好消化消化。这部分内容算是反射里比较难懂的部分，有必要好好学习掌握，这样才能在阅读源码时更加顺畅。

2. 正文

2.1 获取泛型超类和泛型接口的相关信息

2.1.1 获取泛型超类的相关信息

在上篇文章 Java筑基——反射（1）：基本类周边信息获取中，我们介绍了

// 获取 Class 对象的普通类型父类
public native Class<? super T> getSuperclass();

但是没有介绍：

// 获取 Class 对象的泛型类型父类
public Type getGenericSuperclass()

这里，我们会重点介绍这个方法的使用。

先介绍一下用于演示的类：

Holder 类，是一个泛型类，它有一个类型参数是 T：

public class Holder<T> {
    public T t;

    public Holder(T t) {
        this.t = t;
    }
}

为了使 Holder 类看起来简洁，我特意省略了 getter/setter 方法。

IntegerHolder类， 是一个普通类，它继承于 Holder，并且给 Holder 的泛型类型参数传递了 Integer 这个实际类型：

public class IntegerHolder extends Holder<Integer>{
    public IntegerHolder(Integer integer) {
        super(integer);
    }
}

准备工作就绪，开始代码测试：

Type type = IntegerHolder.class.getGenericSuperclass();
System.out.println("type = " + type);

在这里，调用 IntegerHolder 对应的 Class 对象上的 getGenericSuperclass()，获取到的是一个 Type 类型的对象。并且打印了 Type 对象的信息。

查看打印结果：

type = com.java.advanced.features.reflect.genericsclass.blog.Holder<java.lang.Integer>

可以看到，通过 getGenericSuperclass() 获取到的 Type 对象里不仅仅包含了 IntegerHolder 的超类 Holder 的信息，还包括了实际类型参数 Integer。

作为对比，getSuperclass() 方法只能获取到 IntegerHolder 的超类 Holder 而已。

Class<? super IntegerHolder> superclass = IntegerHolder.class.getSuperclass();
System.out.println("superclass = " + superclass);

打印结果：

superclass = class com.java.advanced.features.reflect.genericsclass.blog.Holder

到这里，有没有同学会想 Type 是什么？如何分别获取超类信息和实际类型参数的信息？

我们去查一下文档的说明：

可以看到 Type 是一个接口，从 1.5 开始引入的，它有 4 个子接口：GenericArrayType，ParameterizedType，TypeVariable，WildcardType；1 个实现类：Class。

类图如下：

类图中列出了各个子接口以及子接口的方法，希望大家有一个整体的概念。但是，在这里，还不会一一去介绍。我们会在 2.2 中详细介绍 Type 的使用。

回到我们这个小节里，现在我们已经知道了 Type 是什么；接着看如何分别获取超类信息和实际类型参数的信息？

请看下面的测试代码如下：

public class _01_GetGenericSuperClassTest {
    public static void main(String[] args) {
        Type type = IntegerHolder.class.getGenericSuperclass();
        System.out.println("type = " + type);
        if (type instanceof ParameterizedType) {
        	// 把 Type 类型强制类型转换为 ParameterizedType 类型
            ParameterizedType parameterizedType = (ParameterizedType) type;
            // 获取替换了泛型类型参数的实际类型的 Type 对象的数组
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                Class typeArgument = (Class) actualTypeArgument;
                System.out.println("替换泛型类型参数的实际类型为：" + typeArgument.getName());
            }
            // 获取声明了泛型类型的原始类型
            Type rawType = parameterizedType.getRawType();
            Class rawClass = (Class) rawType;
            System.out.println("声明了泛型类型的原始类型为：" + rawClass.getName());
        }
    }
}

打印结果：

type = com.java.advanced.features.reflect.genericsclass.blog.Holder<java.lang.Integer>
替换泛型类型参数的实际类型为：java.lang.Integer
声明了泛型类型的原始类型为：com.java.advanced.features.reflect.genericsclass.blog.Holder

可以看到，代码中通过了 type instanceof ParameterizedType 判断，说明 type 是 ParameterizedType 的一个实例，再看一下 type 的打印是 Holder<Integer>，它是一个泛型类型，对应的是 ParameterizedType。

然后，我们通过调用 ParameterizedType 的两个方法：

Type[] getActualTypeArguments();
Type getRawType();

第一个方法是获取替换了泛型类型参数的实际类型的 Type对象的数组。这个方法里，我们需要注意的是，返回的是一个数组，而且数组的元素也是 Type 类型的。

这是为什么呢？返回一个数组是因为泛型类型参数可以有多个，就像一个方法可以声明多个形式参数一样。数组的元素类型是 Type，这是因为不仅仅是 Class 用于替换类型参数，其他的 Type 子接口也可以。

第二个方法是获取声明了泛型类型的原始类型。需要注意的一点是“原始类型"的概念一定是和泛型类型在一起的。如果不是泛型类型，那么就无所谓原始类型。

2.1.2 获取泛型接口的相关信息

在上篇文章 Java筑基——反射（1）：基本类周边信息获取中，我们介绍了

// 获取 Class 对象的直接继承或实现的接口的 Class 对象列表
public Class<?>[] getInterfaces()

但是没有介绍：

// 获取 Class 对象的直接继承或实现的泛型接口 Class 对象列表
public Type[] getGenericInterfaces()

本小节，我们会重点介绍这个方法的使用。

先介绍一下，参与测试的类：

Generator 是一个泛型接口，定义了一个生成器，定义一个 next() 方法：

public interface Generator<T> {
    T next();
}

IntegerGenerator 实现了 Generator 接口和 Serializable 接口，使用 Integer 替换泛型接口 Generator 的类型参数：

public class IntegerGenerator implements Generator<Integer>, Serializable {
    Random random = new Random();
    @Override
    public Integer next() {
        return random.nextInt();
    }
}

下面看测试代码：

Type[] types = IntegerGenerator.class.getGenericInterfaces();
for (Type type : types) {
    System.out.println("type = " + type);
}

打印结果：

type = com.java.advanced.features.reflect.genericsclass.blog.Generator<java.lang.Integer>
type = interface java.io.Serializable

可以看到，getGenericInterfaces() 不仅可以获取泛型类型的超类接口，还可以获取普通类型的超类接口。

和 2.1.1 中同样地，我们对获取到的 Type 对象进一步拆分出需要的信息。

测试代码如下：

public class _02_GetGenericInterfacesTest {
    public static void main(String[] args) {
        Type[] types = IntegerGenerator.class.getGenericInterfaces();
        for (Type type : types) {
            System.out.println("type = " + type);
            if (type instanceof ParameterizedType) {
                ParameterizedType parameterizedType = (ParameterizedType) type;
                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    Class typeArgument = (Class) actualTypeArgument;
                    System.out.println("替换泛型类型参数的实际类型为： " + typeArgument);
                }
                Type rawType = parameterizedType.getRawType();
                Class rawClass = (Class) rawType;
                System.out.println("声明了泛型接口的原始类型为： " + rawClass);
            }
        }
    }
}

打印信息：

type = com.java.advanced.features.reflect.genericsclass.blog.Generator<java.lang.Integer>
替换泛型类型参数的实际类型为： class java.lang.Integer
声明了泛型接口的原始类型为： interface com.java.advanced.features.reflect.genericsclass.blog.Generator
type = interface java.io.Serializable

2.2 Type

在 2.1 中，演示了 ParameterizedType 和 Class 的使用，本节会演示 TypeVariable，GenericArrayType 和 WildcardType 的使用。

2.2.1 ParameterizedType

ParameterizedType 表示参数化类型，如 Collection<String>。

2.2.2 TypeVariable

文档上的定义是，TypeVariable 是各种类型变量的公共高级接口。可是看了之后，还是不能明白。
我们可以这样理解：当获取到的 Type 对象表示是一个泛型的类型参数时，它就是 TypeVariable。

下面我们仍是会通过代码演示。

首先，定义一个 NumberGenerator 泛型接口，它有一个泛型类型参数 T，限定为 Number 及其子类型；NumberGenerator 接口继承于 Generator 接口。

public interface NumberGenerator<T extends Number> extends Generator<T>{
}

测试代码如下：

public class _03_TypeVariableTest {
    public static void main(String[] args) {
        // 获取此接口直接继承的接口对应的 Type 对象数组
        Type[] types = NumberGenerator.class.getGenericInterfaces();
        for (Type type : types) {
            System.out.println("type = " + type); // 打印：Generator<T>
            if (type instanceof ParameterizedType) {
                ParameterizedType parameterizedType = (ParameterizedType) type;
                // 获取替换了泛型类型参数的实际类型的 Type 对象数组
                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                   if( actualTypeArgument instanceof TypeVariable) {
                       TypeVariable typeVariable = (TypeVariable) actualTypeArgument;
                       System.out.println("泛型类型参数的名字为 " + typeVariable.getName()); // 打印：T
                       Type[] bounds = typeVariable.getBounds();
                       for (Type bound : bounds) {
                           Class boundClass = (Class) bound;
                           System.out.println("泛型类型参数的上界为：" + boundClass.getName()); // 打印：java.lang.Number
                       }
                   }
                }
            }
        }
    }
}

打印结果：

type = com.java.advanced.features.reflect.genericsclass.blog.Generator<T>
泛型类型参数的名字为 T
泛型类型参数的上界为：java.lang.Number

上面的测试代码看着可能觉得有点多，我们一点一点来看，肯定能够全部理解的。

首先，看获取 ParameterizedType 的部分：

// 获取此接口直接继承的接口对应的 Type 对象数组
Type[] types = NumberGenerator.class.getGenericInterfaces();
for (Type type : types) {
    System.out.println("type = " + type); // 打印：Generator<T>
    if (type instanceof ParameterizedType) {
        ParameterizedType parameterizedType = (ParameterizedType) type;

大家不要去想 for-each 循环，我们这里 types 数组的长度就是 1，因为 NumberGenerator 直接继承的接口只有一个，就是 Generator。
看一下这里获取到的 type 的值：

type = com.java.advanced.features.reflect.genericsclass.blog.Generator<T>

Generator<T> 说明 type 是一个泛型类型，即参数化类型，对应的是 ParameterizedType。因此，可以通过 type instanceof ParameterizedType 的条件判断，进而把 type 强制类型转换为 ParameterizedType 类型。

接着，调用 getActualTypeArguments() 方法，获取替换了泛型类型参数的实际类型的 Type 对象数组：

// 获取替换了泛型类型参数的实际类型的 Type 对象数组
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();

我们这里 parameterizedType，即对应 Generator<T>。其实，这里并没有使用实际类型替换泛型类型参数，只是传入了一个类型参数而已。

因为 Generator<T> 只有一个类型参数，所以 actualTypeArguments 数组的长度是 1。

最后，看 TypeVariable 的部分：

if( actualTypeArgument instanceof TypeVariable) {
    TypeVariable typeVariable = (TypeVariable) actualTypeArgument;
    System.out.println("泛型类型参数的名字为 " + typeVariable.getName()); // 打印：T
    Type[] bounds = typeVariable.getBounds();
    for (Type bound : bounds) {
        Class boundClass = (Class) bound;
        System.out.println("泛型类型参数的上界为：" + boundClass.getName()); // 打印：java.lang.Number
    }
}

打印信息：

泛型类型参数的名字为 T
泛型类型参数的上界为：java.lang.Number

判断 actualTypeArgument 这个 Type 对象是否是 TypeVariable，通过判断；接着把 actualTypeArgument 强制类型转换为 TypeVariable 类型。

调用 TypeVariable 的两个函数：

String getName();
Type[] getBounds();

第一个函数是获取泛型类型参数的名字，这里获取到的是 T，这和定义 Generator<T> 时的类型参数是一样的；
第二个参数是获取泛型类型参数的上边界的 Type 数组。这里泛型类型参数 T 只有一个限定类型：Number。

2.2.3 GenericArrayType

文档中的定义，GenericArrayType 表示一种数组类型，其组件类型为参数化类型或类型变量。

这句话告诉我们，组成 GenericArrayType 这个数组类型的元素要么是参数化类型ParameterizedType，要么是类型变量 TypeVariable。其他的类型如 Class，WildcardType，GenericArrayType 都不可以。

下面我们通过代码来演示。

首先，定义一个 ListArrayGenerator 普通接口，继承于 Generator 泛型接口，并且使用 List<Integer>[] 这个实际类型替换了泛型类型参数：

public interface ListArrayGenerator extends Generator<List<Integer>[]>{
}

完整的测试代码如下：

public class _04_GenericArrayTypeTest {
    public static void main(String[] args) {
        Type[] types = ListArrayGenerator.class.getGenericInterfaces();
        for (Type type : types) {
            System.out.println("type = " + type); // Generator<List<Integer>[]>
            if (type instanceof ParameterizedType) {
                ParameterizedType parameterizedType = (ParameterizedType) type;
                // 获取替换了泛型类型参数的实际类型的Type数组
                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    if (actualTypeArgument instanceof GenericArrayType) {
                        GenericArrayType genericArrayType = (GenericArrayType) actualTypeArgument;
                        System.out.println("替换了泛型类型参数的实际类型为： " + genericArrayType);
                        Type genericComponentType = genericArrayType.getGenericComponentType();
                        System.out.println("泛型数组类型的元素类型为： " + genericComponentType);
                    }
                }
            }
        }
    }
}

打印结果如下：

type = com.java.advanced.features.reflect.genericsclass.blog.Generator<java.util.List<java.lang.Integer>[]>
替换了泛型类型参数的实际类型为： java.util.List<java.lang.Integer>[]
泛型数组类型的元素类型为： java.util.List<java.lang.Integer>

同样地，我们仍是一行一行地看上面的代码，这样可以更好地理解。

首先，看获取 ParameterizedType 的部分：

Type[] types = ListArrayGenerator.class.getGenericInterfaces();
for (Type type : types) {
    System.out.println("type = " + type); // Generator<List<Integer>[]>
    if (type instanceof ParameterizedType) {
        ParameterizedType parameterizedType = (ParameterizedType) type;

ListArrayGenerator 继承的接口 Generator<List<Integer>[]> 是一个泛型接口，即参数化类型，对应的是 ParameterizedType，因此，type 可以通过 type instanceof ParameterizedType 的判断，进而把 type 强转为 ParameterizedType 类型。

其次，调用 getActualTypeArguments() 方法，获取替换了泛型类型参数的实际类型的 Type 对象数组：

// 获取替换了泛型类型参数的实际类型的Type数组
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();

这里的 parameterizedType，即 Generator<List<Integer>[]>，替换了泛型类型参数的实际类型是 List<Integer>[]，对应的是 ArrayGenericType。

最后，看 GenericArrayType 部分：

if (actualTypeArgument instanceof GenericArrayType) {
    GenericArrayType genericArrayType = (GenericArrayType) actualTypeArgument;
    System.out.println("替换了泛型类型参数的实际类型为： " + genericArrayType);
    Type genericComponentType = genericArrayType.getGenericComponentType();
    System.out.println("泛型数组类型的元素类型为： " + genericComponentType);
}

打印信息：

替换了泛型类型参数的实际类型为： java.util.List<java.lang.Integer>[]
泛型数组类型的元素类型为： java.util.List<java.lang.Integer>

上面的 actualTypeArgument，对应的是 GenericArrayType，因此通过 actualTypeArgument instanceof GenericArrayType 判断，把 actualTypeArgument 强转为 GenericArrayType 类型。
调用 GenericArrayType 的函数：

Type getGenericComponentType();

这个函数的作用是获取泛型数组类型的元素类型。这里得到的是 List<Integer>类型。
进一步，我们可以验证这里的元素类型是 ParameterizedType:

if (genericComponentType instanceof ParameterizedType) {
    System.out.println("泛型数组类型的元素类型是ParameterizedType");
}

2.2.4 WildcardType

文档上的定义，WildcardType 表示一个通配符类型表达式，如 ?、? extends Number 或 ? super Integer。

定义一个 NumberListGenerator 接口，它继承于 Generator 接口，并且使用 List<? extends Number> 来替换 Generator 泛型接口的类型参数 T：

public interface NumberListGenerator extends Generator<List<? extends Number>>{
}

下面是完整的测试代码：

public class _05_WildcardTypeTest {
    public static void main(String[] args) {
        Type[] types = NumberListGenerator.class.getGenericInterfaces();
        for (Type type : types) {
            System.out.println("type = " + type); // Generator<List<? extends Number>>
            if (type instanceof ParameterizedType) {
                ParameterizedType parameterizedType = (ParameterizedType) type;
                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    if (actualTypeArgument instanceof ParameterizedType) {
                        ParameterizedType typeArgument = (ParameterizedType) actualTypeArgument;
                        Type[] actualTypeArguments1 = typeArgument.getActualTypeArguments();
                        for (Type type1 : actualTypeArguments1) {
                            if (type1 instanceof WildcardType) {
                                WildcardType wildcardType = (WildcardType) type1;
                                System.out.println("wildcardType = " + wildcardType);
                                Type[] lowerBounds = wildcardType.getLowerBounds();
                                for (Type lowerBound : lowerBounds) {
                                    System.out.println("lowerBound = " + lowerBound);
                                }
                                Type[] upperBounds = wildcardType.getUpperBounds();
                                for (Type upperBound : upperBounds) {
                                    System.out.println("upperBound = " + upperBound);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

这段代码长得有点可以了。不过，我们仍然是一点点地看，一定会弄明白的。

首先，看获取 ParameterizedType 的部分：

Type[] types = NumberListGenerator.class.getGenericInterfaces();
for (Type type : types) {
    System.out.println("type = " + type); // Generator<List<? extends Number>>
    if (type instanceof ParameterizedType) {
        ParameterizedType parameterizedType = (ParameterizedType) type;

NumberListGenerator 继承的接口 Generator<List<? extends Number>> 是一个泛型接口，即参数化类型，对应的是 ParameterizedType，因此，type 可以通过 type instanceof ParameterizedType 的判断，进而把 type 强转为 ParameterizedType 类型。

其次，调用 getActualTypeArguments() 方法，获取替换了泛型类型参数的实际类型的 Type 对象数组：

Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();

这里的 parameterizedType，即 Generator<List<? extends Number>>，替换了泛型类型参数的实际类型是 List<? extends Number>，对应的是 ParameterizedType。

接着，把上一步获取到的实际类型，通过类型转换为 ParameterizedType：

for (Type actualTypeArgument : actualTypeArguments) {
    if (actualTypeArgument instanceof ParameterizedType) {
        ParameterizedType typeArgument = (ParameterizedType) actualTypeArgument;

这一步的 typeArgument 是一个 ParameterizedType 类型，对应的是 List<? extends Number>。

接着，既然 typeArgument 是一个 ParameteizedType 类型，我们可以调用 getActualTypeArguments() 方法获取替换了泛型类型参数的实际类型：

Type[] actualTypeArguments1 = typeArgument.getActualTypeArguments();

这里的 typeArgument 是一个 ParameterizedType 类型，对应的是 List<? extends Number>；通过调用 getActualTypeArguments() 方法，获取到的就是替换了List<T> 泛型接口的类型参数 T 的实际类型，即 ? extends Number。

接着，把上一步获取到的就是替换了List<T> 泛型接口的类型参数 T 的实际类型类型转换为 WildcardType 类型：

for (Type type1 : actualTypeArguments1) {
    if (type1 instanceof WildcardType) {
        WildcardType wildcardType = (WildcardType) type1;

最后，调用 WildcardType 的两个方法：

Type[] getUpperBounds();
Type[] getLowerBounds();

来获取上边界和下边界的信息。

代码如下：

Type[] lowerBounds = wildcardType.getLowerBounds();
for (Type lowerBound : lowerBounds) {
    System.out.println("lowerBound = " + lowerBound);
}
Type[] upperBounds = wildcardType.getUpperBounds();
for (Type upperBound : upperBounds) {
    System.out.println("upperBound = " + upperBound);
}

打印信息：

upperBound = class java.lang.Number

3. 最后

本文介绍了泛型类的周边信息获取，以及 Type 体系，希望能够帮助到大家。巩固好反射知识，对于阅读框架源码是很有帮助的。

文末的参考链接，大家也可以看一下，都是很不错的文章。

参考

Java之Holder技术
06-02
为了解决上面提到的将函数内分配的空间传递到函数外的过程，Holder技术被发现了。原理其实非常简单，引用类型在函数执行的前后可以改变的是引用类型指向的内容，那么将我们想要的引用类型封装在另外一个引用类型中就可以对我们想要的引用类型进行自由变化了。
夯实JAVA基本之一——泛型详解(2)：高级进阶
启舰
11-17 2万+
前言：被温水煮惯了，梦想的东西总是不敢于尝试，失败了又怎样，最多从头来过。 相关文章： 1、《夯实JAVA基本之一 —— 泛型详解(1):基本使用》 2、《夯实JAVA基本之一——泛型详解(2)：高级进阶》 3、《夯实JAVA基本之二 —— 反射（1）：基本类周边信息获取》 4、《夯实JAVA基本之二 —— 反射（2）：泛型相关周边信息获取》 5、《夯实JAVA基本之二 —— ...
获取类声明的泛型的工具类
SOLO的博客
07-25 519
记录一下 适用于找类似如下声明中的泛型,T 和E的值 class A<T extends B,E extends C>{ } class C extends A<T1,E1>{ } class D extends C{ } 该工具支持遍历 也就是，可以在D中寻找到T1和E1的类型 import java.lang.reflect.Pa
java根据方法出入参自动生成json示例
qq_42553504的博客
06-17 1345
java代码主要根据反射，为出入参为引用属性，时设置默认值。最后由fastjson 转为json字符串。
getSimpleName(),getClass(),getGenericSuperclass()和getActualTypeArguments()的返回结果
weixin_42988712的博客
11-09 1773
getSimpleName(),getClass(),getGenericSuperclass()和getActualTypeArguments()的返回结果
JAVA反射（二）
Fjtd_2019的博客
04-06 1218
在之前有写了关于JAVA反射的理解以及几种用法，今天主要想记一下常用一些功能以及一些注意的地方，为了使功能尽量全面，我们以一个包含比较丰富的实体类为例： 首先是新建一个自定义的注解、以及接口： 接下来新建一个Creature类： 接下来新建一个Person类，继承自Creature类，实现上面的自定义接口和一个自带的Comparable接口，以及引用自定义注解： 其中Person类属性有姓...
夯实JAVA基本之一 —— 泛型详解(1):基本使用
热门推荐
启舰
11-16 2万+
前言：无论何时，相信自己。 相关文章： 1、《夯实JAVA基本之一 —— 泛型详解(1):基本使用》 2、《夯实JAVA基本之一——泛型详解(2)：高级进阶》 3、《夯实JAVA基本之二 —— 反射（1）：基本类周边信息获取》 4、《夯实JAVA基本之二 —— 反射（2）：泛型相关周边信息获取》 5、《夯实JAVA基本之二 —— 反射（3）：类内部信息获取》 一、引入 ...
Java筑基——反射（1）：基本类周边信息获取
willwaywang6
05-31 1544
本文会介绍反射相关的知识，为了不和泛型类的方法混在一起，本文集中介绍基本类的反射知识。主要内容包括： - 类的生命周期是什么？ - 有几种方式获取类类型，这些方式之间的区别是什么？ - 如何获取类的超类或实现的接口？ - 如何获取类及接口的访问修饰符？ - 获取类名的几种方法及区别。
夯实JAVA基本之二 —— 反射（2）：泛型相关周边信息获取
启舰
11-28 1万+
前言：坚信自己坚信的，坚持自己坚持的，永远选择相信自己。 相关文章： 1、《夯实JAVA基本之一 —— 泛型详解(1):基本使用》 2、《夯实JAVA基本之一——泛型详解(2)：高级进阶》 3、《夯实JAVA基本之二 —— 反射（1）：基本类周边信息获取》 4、《夯实JAVA基本之二 —— 反射（2）：泛型相关周边信息获取》 5、《夯实JAVA基本之二 —— 反射（3）：类内部信息...
Java之泛型ParameterizedType、getGenericSuperclass、getActualTypeArguments
LVXIANGAN的专栏
07-06 4684
在反射中，我们经常遇到这样代码：ParameterizedType、getGenericSuperclass、getActualTypeArguments，今天就让我们来了解一下。 先来看一段代码： 这段代码啥意思？引用一段测试代码： public class Person<T> { } import java.lang.reflect.Parameterize...
type java_Java中的Type
weixin_35135418的博客
02-12 334
下面就用代码的方式，对其中的5大类型：原始类型(Class)、参数化类型(ParameterizedType)、数组类型(GenericArrayType)、类型变量(TypeVariable)、基本类型(Class) 进一步说明；1.ParameterizedTypeParameterizedType表示参数化类型，也就是泛型，例如List、Set等；ParameterizedType在Para...
Hutool工具类和工具方法
青春不散场的专栏
11-02 4306
基础工具类： StrUtil/StringUtils -字符串工具类 添加移除：addXXX/appendXXX/removeXXX 判断:containsXXX/startWithXXX/endWithXXX/indexOfXXX/lastIndexOfXXX/ordinalIndexOf/ isAllCharMatchisBlankIfStr/isBlankOrUndefined/isNullOrUndefined/hasBlank/hasEmpty/ isEmpty/isNotE
java getactualtypearguments_Java泛型小记
weixin_33771816的博客
02-28 4306
前言经常会看到 “泛型会在编译期擦除，但是运行时可以获取到”，自己也有过这样的疑惑。此处做一下笔记，记录一下认识和理解。一、泛型概述二、获取泛型类型3.1、demo文章中列出了几种可以通过反射在 runtime 获取泛型类型的情况：package bean;import java.lang.reflect.*;import java.util.HashMap;import java.util.Li...
Hutool工具包的工具类和方法整理
青春不散场的专栏
08-23 3143
【代码】Hutool工具包的工具类和方法整理。
getGenericSuperclass()和getActualTypeArguments()[0]是什么？
qq_24353093的博客
12-16 1491
今天学习的时候，看到BaseDao有这样的代码： protected GenericDAO(T) { type = getClass().getGenericSuperclass(); Type trueType = ((ParameterizedType) type).getActualTypeArguments()[0]; this.entityClass = (Class&lt;T1...
aop获取调用方法返回类型(泛型)
qq_40757662的博客
11-20 3472
String className = ((ParameterizedType) TypeUtil.getTypeArgument(((MethodSignature) pjp.getSignature()).getMethod().getGenericReturnType())) .getActualTypeArguments()[0].getTypeName(); Class<?> aClass = Class.forName(...
Java基础（7）反射
phliny的博客
07-12 319
反射机制 1，概念 Reflection（反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取 得任何类的内部信息，并能直接操作任意对象的内部属性及方法。 加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这 个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子， 透过这个镜子看到类的结构，所以，我们形象的称之为：反射 2，Java反射机制提供的功能 在运行时判断任意一个对象所属
获取泛型的实际类型
qq_32434535的博客
07-12 4042
获取泛型的实际类型
ParameterizedType、GenericArrayType、TypeVariable中常用的方法
m0_56362438的博客
11-20 611
ParameterizedType 接口是 Java 中的一个类型接口，它用于表示带有泛型参数的类型，例如 List 或 Map<Integer, String> 等。getActualTypeArguments()方法，例如 List ,Map<String,Long> 获取的是<>里面的参数,getRawType()表示此类型的原始类型的 Type 例如 Map<String,Long> 获取到的是map原始对象。结果为，成功的获取到了的上边界 list。结果为 获取到了<>里面的参数。
使用getGenericSuperclass()和getActualTypeArguments()将DAO做成泛型
11-29 939
一、getGenericSuperclass()和getActualTypeArguments()基本用法： import java.lang.reflect.ParameterizedType; public class TT extendsTT2 { public static void main(String[] args) { System.out.prin
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

willwaywang6

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值