2.反射系列：反射获得泛型参数

傷城~ 2022-05-10 00:14 230阅读 0赞

public class Person<T> {
         
        }
     
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
     
    public class Student extends Person<Student> {
    public static void main(String[] args) {
    Student st=new Student();
    Class clazz=st.getClass();
    //getSuperclass()获得该类的父类
    System.out.println(clazz.getSuperclass());
    //getGenericSuperclass()获得带有泛型的父类
    //Type是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。
    Type type=clazz.getGenericSuperclass();
    System.out.println(type);
    //ParameterizedType参数化类型，即泛型
    ParameterizedType p=(ParameterizedType)type;
    //getActualTypeArguments获取参数化类型的数组，泛型可能有多个
    Class c=(Class) p.getActualTypeArguments()[0];
    System.out.println(c);
    }
    }
     
    打印结果：
     
    class com.test.Person
    com.test.Person<com.test.Student>
    class com.test.Student

ParameterizedType

*  getClass().getGenericSuperclass() 返回表示此 Class 所表示的实体（类、接口、基本类型或  
    void）的直接超类的 Type，然后将其转换ParameterizedType。
 *  getActualTypeArguments() 返回表示此类型实际类型参数的 Type  
    对象的数组。\[0\]就是这个数组中第一个了。简而言之就是获得超类的泛型参数的实际类型。 看意思可能不是很懂，我们直接看例子

--------------------

package com.chen.demo;
    
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    
    class param<T1, T2> {  
    
        class A {}  
        class B extends A {}  
    
        private Class<T1> entityClass;  
        public param (){  
            Type type = getClass().getGenericSuperclass();  
            System.out.println("getClass() == " + getClass());  
            System.out.println("type = " + type);  
            Type trueType = ((ParameterizedType)type).getActualTypeArguments()[0];  
            System.out.println("trueType1 = " + trueType);  
            trueType = ((ParameterizedType)type).getActualTypeArguments()[1];  
            System.out.println("trueType2 = " + trueType);  
            this.entityClass = (Class<T1>)trueType;  
            System.out.println("entityClass = " + entityClass);
    
            B t = new B();  
            type = t.getClass().getGenericSuperclass();  
    
            System.out.println("B is A's super class :" + ((ParameterizedType)type).getActualTypeArguments().length);  
        }  
    
    }  
    
    public class ClassDemo extends param<MyClass, MyInvoke>{
        public static void main(String[] args) {
            ClassDemo classDemo = new ClassDemo();
        }
    }
    
    
    package com.chen.demo;
    
    public class MyClass {
    
    }
    
    package com.chen.demo;
    
    public class MyInvoke {
    
    }

我们再看打印结果

getClass() == class com.chen.demo.ClassDemo
    type = com.chen.demo.param<com.chen.demo.MyClass, com.chen.demo.MyInvoke>
    trueType1 = class com.chen.demo.MyClass
    trueType2 = class com.chen.demo.MyInvoke
    entityClass = class com.chen.demo.MyInvoke
    B is A's super class :0