Java类加载与反射

Java类加载与反射

类加载、连接、初始化

JVM和类

当运行某个Java程序时,将会启动一个Java虚拟机进程,不管Java程序里面多么复杂,都处于该Java虚拟机进程里面。

当Java程序运行结束,JVM进程结束,该进程在内存中的状态将丢失


public class A {

    // 定义该类的类变量
    public static int a = 6;

    
}

接下来创建A类的实例

public class ATest1 {

    public static void main(String[] args)
    {
        // 创建A类的实例
        A a = new A();
        // 让a实例的类变量a的值自加
        a.a ++;
        System.out.println(a.a);
    }


}

下面这个也进行同样操作

public class ATest2 {

    public static void main(String[] args) {

        // 创建A类的实例
        A b = new A();
        // 输出b实例的类变量a的值
        System.out.println(b.a);

    }
}

当运行第二个ATest2时,程序再次创建了A对象,并输出a的值,为6,这是因为运行ATest1和ATest2是两次运行JVM进程,第一次JVM结束后,对A类的修改全部丢失

类加载

当主动使用某个类时,如果该类还未被加载到内存中,则系统会通过加载、连接、初始化三个步骤来对该类进行初始化

类加载是将类的class文件读入内存,并为之创建一个java.lang.Class对象

类的加载由类加载器完成,类加载器通常由JVM提供

类连接

当类被加载后,系统为之生成一个对应的Class对象,接着进入连接阶段,类连接又分为:

  • 验证

  • 准备

  • 解析

类初始化

虚拟机负责对类进行初始化,主要是对类变量进行初始化

public class Test {

    static
    {
        // 使用静态初始化块为变量b指定出初始值
        b = 6;
        System.out.println("----------");
    }
    // 声明变量a时指定初始值
    static int a = 5;
    static int b = 9;         // ①
    static int c;
    public static void main(String[] args)
    {
        System.out.println(Test.b);
    }
}

类初始化时机

当Java程序首次通过下面6钟方式来使用某个类或接口,系统就会初始化该类或接口

  • 创建类实例(通过new操作符、反射、反序列化)

  • 调用某个类的类方法(静态方法)

  • 访问某个类或接口的类变量

  • 反射强制创建

  • 初始化某个类的子类

  • 直接使用java.exe运行某个主类

class MyTest
{
    static
    {
        System.out.println("静态初始化块...");
    }
    // 使用一个字符串直接量为static final的类变量赋值
    static final String compileConstant = "Java";
}
public class CompileConstantTest
{
    public static void main(String[] args)
    {
        // 访问、输出MyTest中的compileConstant类变量
        System.out.println(MyTest.compileConstant);   // ①
    }
}


System.out.println(MyTest.compileConstant)不会导致初始化MyTest类

类加载器

类加载器负责将.class文件加载到内存,并为之生成对应的java.lang.Class对象

类加载机制

类加载器负责加载所有类,系统为载入内存的类生成实例,一旦一个类被载入JVM,同一个类就不会被再次载入

JVM启动,会形成三个类加载器组成的初始类加载器层次结构

  • 根类加载器

  • 扩展类加载器

  • 系统类加载器


public class ClassLoaderPropTest {
    public static void main(String[] args)
            throws IOException
    {
        // 获取系统类加载器
        ClassLoader systemLoader = ClassLoader.getSystemClassLoader();
        System.out.println("系统类加载器:" + systemLoader);
		/*
		获取系统类加载器的加载路径——通常由CLASSPATH环境变量指定
		如果操作系统没有指定CLASSPATH环境变量,默认以当前路径作为
		系统类加载器的加载路径
		*/
        Enumeration<URL> em1 = systemLoader.getResources("");
        while(em1.hasMoreElements())
        {
            System.out.println(em1.nextElement());
        }
        // 获取系统类加载器的父类加载器:得到扩展类加载器
        ClassLoader extensionLader = systemLoader.getParent();
        System.out.println("扩展类加载器:" + extensionLader);
        System.out.println("扩展类加载器的加载路径:"
                + System.getProperty("java.ext.dirs"));
        System.out.println("扩展类加载器的parent: "
                + extensionLader.getParent());
    }
}

反射

Java中许多对象在运行时都会出现两种类型

  • 编译时类型

  • 运行时类型

有时我们需要在运行时发现对象和类的真实信息

  • 假设在编译和运行时都完全知道了类型的具体信息,这样可以先使用instanceof运算符进行判断,再进行强制类型转换

  • 编译时无法预知该对象和类可能属于哪些类,程序只依靠运行时信息来发现该对象和类的真实信息,这就要使用反射了

获取Class对象

每个类被加载后,系统会为该类生成一个对应的Class对象,通过该Class对象就可以访问到JVM中的这个类,获取Class对象有三种方式:

  • Class类的forName()静态方法,传入字符串参数

  • 调用某个类的class属性来获取,如Person.class将会返回Person类对应的class对象

  • 调用某个对象的getClass()

从Class获取信息

例子:


// 定义可重复注解
@Repeatable(Annos.class)
@interface Anno {}
@Retention(value= RetentionPolicy.RUNTIME)
@interface Annos {
    Anno[] value();
}
// 使用4个注解修饰该类
@SuppressWarnings(value="unchecked")
@Deprecated
// 使用重复注解修饰该类
@Anno
@Anno
public class ClassTest
{
    // 为该类定义一个私有的构造器
    private ClassTest()
    {
    }
    // 定义一个有参数的构造器
    public ClassTest(String name)
    {
        System.out.println("执行有参数的构造器");
    }
    // 定义一个无参数的info方法
    public void info()
    {
        System.out.println("执行无参数的info方法");
    }
    // 定义一个有参数的info方法
    public void info(String str)
    {
        System.out.println("执行有参数的info方法"
                + ",其str参数值:" + str);
    }
    // 定义一个测试用的内部类
    class Inner
    {
    }


    public static void main(String[] args)
            throws Exception
    {
        // 下面代码可以获取ClassTest对应的Class
        Class<ClassTest> clazz = ClassTest.class;
        // 获取该Class对象所对应类的全部构造器
        Constructor[] ctors = clazz.getDeclaredConstructors();
        System.out.println("ClassTest的全部构造器如下:");
        for (Constructor c : ctors)
        {
            System.out.println(c);
        }


        System.out.println("");
        System.out.println("======================================================");
        System.out.println("");



        // 获取该Class对象所对应类的全部public构造器
        Constructor[] publicCtors = clazz.getConstructors();
        System.out.println("ClassTest的全部public构造器如下:");
        for (Constructor c : publicCtors)
        {
            System.out.println(c);
        }


        System.out.println("");
        System.out.println("======================================================");
        System.out.println("");



        // 获取该Class对象所对应类的全部public方法
        Method[] mtds = clazz.getMethods();
        System.out.println("ClassTest的全部public方法如下:");
        for (Method md : mtds)
        {
            System.out.println(md);
        }


        System.out.println("");
        System.out.println("======================================================");
        System.out.println("");


        // 获取该Class对象所对应类的指定方法
        System.out.println("ClassTest里带一个字符串参数的info()方法为:"
                + clazz.getMethod("info" , String.class));



        System.out.println("");
        System.out.println("======================================================");
        System.out.println("");



        // 获取该Class对象所对应类的上的全部注解
        Annotation[] anns = clazz.getAnnotations();
        System.out.println("ClassTest的全部Annotation如下:");
        for (Annotation an : anns)
        {
            System.out.println(an);
        }

        System.out.println("");
        System.out.println("======================================================");
        System.out.println("");


        System.out.println("该Class元素上的@SuppressWarnings注解为:"
                + Arrays.toString(clazz.getAnnotationsByType(SuppressWarnings.class)));

        System.out.println("");
        System.out.println("======================================================");
        System.out.println("");


        System.out.println("该Class元素上的@Anno注解为:"
                + Arrays.toString(clazz.getAnnotationsByType(Anno.class)));

        System.out.println("");
        System.out.println("======================================================");
        System.out.println("");


        // 获取该Class对象所对应类的全部内部类
        Class<?>[] inners = clazz.getDeclaredClasses();
        System.out.println("ClassTest的全部内部类如下:");
        for (Class c : inners)
        {
            System.out.println(c);
        }


        System.out.println("");
        System.out.println("======================================================");
        System.out.println("");


        // 使用Class.forName方法加载ClassTest的Inner内部类
        Class inClazz = Class.forName("C_2.c_2_3.ClassTest$Inner");
        // 通过getDeclaringClass()访问该类所在的外部类
        System.out.println("inClazz对应类的外部类为:" +
                inClazz.getDeclaringClass());


        System.out.println("");
        System.out.println("======================================================");
        System.out.println("");


        System.out.println("ClassTest的包为:" + clazz.getPackage());

        System.out.println("");
        System.out.println("======================================================");
        System.out.println("");


        System.out.println("ClassTest的父类为:" + clazz.getSuperclass());

        System.out.println("");
        System.out.println("======================================================");
        System.out.println("");
    }
}

Java 8 新增方法参数反射


class Test_1
{
    public void replace(String str, List<String> list){}
}
public class MethodParameterTest
{
    public static void main(String[] args)throws Exception
    {
        // 获取String的类
        Class<Test_1> clazz = Test_1.class;


        // 获取String类的带两个参数的replace()方法
        Method replace = clazz.getMethod("replace"
                , String.class, List.class);


        // 获取指定方法的参数个数
        System.out.println("replace方法参数个数:" + replace.getParameterCount());


        // 获取replace的所有参数信息
        Parameter[] parameters = replace.getParameters();


        int index = 1;
        // 遍历所有参数
        for (Parameter p : parameters)
        {
            if (p.isNamePresent())
            {
                System.out.println("---第" + index++ + "个参数信息---");
                System.out.println("参数名:" + p.getName());
                System.out.println("形参类型:" + p.getType());
                System.out.println("泛型类型:" + p.getParameterizedType());
            }
        }
    }
}

使用反射生成并操作对象

创建对象

通过反射生成对象需要先使用Class对象获取指定的Constructor对象,再用Constructor对象的newInstance()创建该Class对象对应类的实例

public class ObjectPoolFactory {

    // 定义一个对象池,前面是对象名,后面是实际对象
    private Map<String ,Object> objectPool = new HashMap<>();
    // 定义一个创建对象的方法
    // 该方法只要传入一个字符串类名,程序可以根据该类名生成Java对象
    private Object createObject(String clazzName)
            throws Exception
            , IllegalAccessException , ClassNotFoundException
    {
        // 根据字符串来获取对应的Class对象
        Class<?> clazz = Class.forName(clazzName);
        // 使用clazz对应类的默认构造器创建实例
        return clazz.getConstructor().newInstance();
    }
    // 该方法根据指定文件来初始化对象池
    // 它会根据配置文件来创建对象
    public void initPool(String fileName)
            throws InstantiationException
            , IllegalAccessException ,ClassNotFoundException
    {
        try(
                FileInputStream fis = new FileInputStream(fileName))
        {
            Properties props = new Properties();
            props.load(fis);
            for (String name : props.stringPropertyNames())
            {
                // 每取出一对key-value对,就根据value创建一个对象
                // 调用createObject()创建对象,并将对象添加到对象池中
                objectPool.put(name ,
                        createObject(props.getProperty(name)));
            }
        }
        catch (Exception ex)
        {
            System.out.println("读取" + fileName + "异常");
        }
    }
    public Object getObject(String name)
    {
        // 从objectPool中取出指定name对应的对象
        return objectPool.get(name);
    }
    public static void main(String[] args)
            throws Exception
    {
        ObjectPoolFactory pf = new ObjectPoolFactory();
        pf.initPool("obj.txt");
        System.out.println(pf.getObject("a"));      // ①
        System.out.println(pf.getObject("b"));      // ②
    }
}


调用方法

获取某个类对应的Class对象后,就可以通过该Class对象的getMethods()获取全部方法

Method里面有一个invoke()方法:

Object invoke(Object obj,Object…args);

obj是执行方法的主调,args是执行该方法时传入该方法的实参


public class ExtendedObjectPoolFactory {


    // 定义一个对象池,前面是对象名,后面是实际对象
    private Map<String ,Object> objectPool = new HashMap<>();
    private Properties config = new Properties();
    // 从指定属性文件中初始化Properties对象
    public void init(String fileName)
    {
        try(
                FileInputStream fis = new FileInputStream(fileName))
        {
            config.load(fis);
        }
        catch (IOException ex)
        {
            System.out.println("读取" + fileName + "异常");
        }
    }
    // 定义一个创建对象的方法
    // 该方法只要传入一个字符串类名,程序可以根据该类名生成Java对象
    private Object createObject(String clazzName)
            throws Exception
    {
        // 根据字符串来获取对应的Class对象
        Class<?> clazz =Class.forName(clazzName);
        // 使用clazz对应类的默认构造器创建实例
        return clazz.getConstructor().newInstance();
    }
    // 该方法根据指定文件来初始化对象池
    // 它会根据配置文件来创建对象
    public void initPool()throws Exception
    {
        for (String name : config.stringPropertyNames())
        {
            // 每取出一个key-value对,如果key中不包含百分号(%)
            // 这就表明是根据value来创建一个对象
            // 调用createObject创建对象,并将对象添加到对象池中
            if (!name.contains("%"))
            {
                objectPool.put(name ,
                        createObject(config.getProperty(name)));
            }
        }
    }
    // 该方法将会根据属性文件来调用指定对象的setter方法
    public void initProperty()throws InvocationTargetException
            ,IllegalAccessException,NoSuchMethodException
    {
        for (String name : config.stringPropertyNames())
        {
            // 每取出一对key-value对,如果key中包含百分号(%)
            // 即可认为该key用于控制调用对象的setter方法设置值
            // %前半为对象名字,后半控制setter方法名
            if (name.contains("%"))
            {
                // 将配置文件中的key按%分割
                String[] objAndProp = name.split("%");
                // 取出调用setter方法的参数值
                Object target = getObject(objAndProp[0]);
                // 获取setter方法名:set + "首字母大写" + 剩下部分
                String mtdName = "set" +
                        objAndProp[1].substring(0 , 1).toUpperCase()
                        + objAndProp[1].substring(1);
                // 通过target的getClass()获取它的实现类所对应的Class对象
                Class<?> targetClass = target.getClass();
                // 获取希望调用的setter方法
                Method mtd = targetClass.getMethod(mtdName , String.class);
                // 通过Method的invoke方法执行setter方法
                // 将config.getProperty(name)的值作为调用setter方法的参数
                mtd.invoke(target , config.getProperty(name));
            }
        }
    }
    public Object getObject(String name)
    {
        // 从objectPool中取出指定name对应的对象
        return objectPool.get(name);
    }
    public static void main(String[] args)
            throws Exception
    {
        ExtendedObjectPoolFactory epf = new ExtendedObjectPoolFactory();
        epf.init("extObj.txt");
        epf.initPool();
        epf.initProperty();
        System.out.println(epf.getObject("a"));
    }
}

访问成员变量值

通过Class对象的getFields()可以获取该类全部成员变量


class Person
{
    private String name;
    private int age;
    public String toString()
    {
        return "Person[name:" + name +
                " , age:" + age + " ]";
    }
}
public class FieldTest
{
    public static void main(String[] args)
            throws Exception
    {
        // 创建一个Person对象
        Person p = new Person();
        // 获取Person类对应的Class对象
        Class<Person> personClazz = Person.class;
        // 获取Person的名为name的成员变量
        // 使用getDeclaredField()方法表明可获取各种访问控制符的成员变量
        Field nameField = personClazz.getDeclaredField("name");
        // 设置通过反射访问该成员变量时取消访问权限检查
        nameField.setAccessible(true);
        // 调用set()方法为p对象的name成员变量设置值
        nameField.set(p , "Yeeku.H.Lee");
        // 获取Person类名为age的成员变量
        Field ageField = personClazz.getDeclaredField("age");
        // 设置通过反射访问该成员变量时取消访问权限检查
        ageField.setAccessible(true);
        // 调用setInt()方法为p对象的age成员变量设置值
        ageField.setInt(p , 30);
        System.out.println(p);
    }
}

操作数组

java.lang.reflect下有一个Array类,Array对象可以代表所有数组,可以使用Array动态创建数组


public class ArrayTest1 {

    public static void main(String[] args) {

        try
        {
            // 创建一个元素类型为String ,长度为10的数组
            Object arr = Array.newInstance(String.class, 10);
            // 依次为arr数组中index为5、6的元素赋值
            Array.set(arr, 5, "Java");
            Array.set(arr, 6, "Java EE");
            // 依次取出arr数组中index为5、6的元素的值
            Object book1 = Array.get(arr , 5);
            Object book2 = Array.get(arr , 6);
            // 输出arr数组中index为5、6的元素
            System.out.println(book1);
            System.out.println(book2);
        }
        catch (Throwable e)
        {
            System.err.println(e);
        }

    }
}

下面创建一个三维数组


public class ArrayTest2 {

    public static void main(String[] args) {
/*
		  创建一个三维数组。
		  根据前面介绍数组时讲的:三维数组也是一维数组,
		  是数组元素是二维数组的一维数组,
		  因此可以认为arr是长度为3的一维数组
		*/
        Object arr = Array.newInstance(String.class, 3, 4, 10);
        // 获取arr数组中index为2的元素,该元素应该是二维数组
        Object arrObj = Array.get(arr, 2);
        // 使用Array为二维数组的数组元素赋值。二维数组的数组元素是一维数组,
        // 所以传入Array的set()方法的第三个参数是一维数组。
        Array.set(arrObj , 2 , new String[]
                {
                        "Java",
                        "Java EE"
                });
        // 获取arrObj数组中index为3的元素,该元素应该是一维数组。
        Object anArr  = Array.get(arrObj, 3);
        Array.set(anArr , 8  , "Android");
        // 将arr强制类型转换为三维数组
        String[][][] cast = (String[][][])arr;
        // 获取cast三维数组中指定元素的值
        System.out.println(cast[2][3][8]);
        System.out.println(cast[2][2][0]);
        System.out.println(cast[2][2][1]);


    }
}


动态代理

java.lang.reflect提供了一个Proxy类和一个InvocationHandler接口

用Proxy和InvocationHandler创建动态代理

Proxy是所有动态代理的父类,可以使用它创建动态代理类以及动态代理实例

Proxy提供了下面两个方法创建动态代理类以及动态代理实例

  • static Class < ? > getProxyClass ( Cl assLoader loader , Class < ? > . . .
    interfaces ) 返回实现指定接口的代理类

  • staticObject newProxyInstance ( ClassLoader loader , Class < ? > [ ]
    interfaces , InvocationHandler handler ) 构造实现指定接口的代理类的一个新实例 所有方法会调用给定处理器对象的 invoke 方法

系统生成的每个代理对象都有一个与之关联的InvocationHandler对象

例子:

interface Person
{
    void walk();
    void sayHello(String name);
}
class MyInvokationHandler implements InvocationHandler
{
    /*
    执行动态代理对象的所有方法时,都会被替换成执行如下的invoke方法
    其中:
    proxy:代表动态代理对象
    method:代表正在执行的方法
    args:代表调用目标方法时传入的实参。
    */
    public Object invoke(Object proxy, Method method, Object[] args)
    {
        System.out.println("----正在执行的方法:" + method);
        if (args != null)
        {
            System.out.println("下面是执行该方法时传入的实参为:");
            for (Object val : args)
            {
                System.out.println(val);
            }
        }
        else
        {
            System.out.println("调用该方法没有实参!");
        }
        return null;
    }
}
public class ProxyTest
{
    public static void main(String[] args)
            throws Exception
    {
        // 创建一个InvocationHandler对象
        InvocationHandler handler = new MyInvokationHandler();
        // 使用指定的InvocationHandler来生成一个动态代理对象
        Person p = (Person) Proxy.newProxyInstance(Person.class.getClassLoader()
                , new Class[]{Person.class}, handler);
        // 调用动态代理对象的walk()和sayHello()方法
        p.walk();
        p.sayHello("孙悟空");
    }
}

动态代理和AOP

假设有三个模块需要用到一个公共的代码段,我们可以把该公共代码段定义成一个方法,然后让这三个模块直接调用就可以了,但是这三个模块又和一个特定的方法耦合了,最好的情况就是模块可以使用到这段公共代码,但又不需要在三个模块中以硬编码的方式直接调用这段公共代码,这个时候就可以使用动态代理了

先上一个Dog接口

public interface Dog {

    // info方法声明
    void info();
    // run方法声明
    void run();


}

再来一个猎狗实现类

public class GunDog implements Dog{

    // 实现info()方法,仅仅打印一个字符串
    public void info()
    {
        System.out.println("我是一只猎狗");
    }
    // 实现run()方法,仅仅打印一个字符串
    public void run()
    {
        System.out.println("我奔跑迅速");
    }


}


现在需求来了,假设info和run就是前面例子中的三个模块中的两个,我们想在这两个方法中实现一段公共代码,但又不想以硬编码方式直接调用,怎么做呢?

假设下面这个就是需要插入的公共代码


public class DogUtil {

    // 第一个拦截器方法
    public void method1()
    {
        System.out.println("=====模拟第一个通用方法=====");
    }
    // 第二个拦截器方法
    public void method2()
    {
        System.out.println("=====模拟通用方法二=====");
    }

    
}

关键实现:

public class MyInvokationHandler implements InvocationHandler {

    // 需要被代理的对象
    private Object target;
    public void setTarget(Object target)
    {
        this.target = target;
    }
    // 执行动态代理对象的所有方法时,都会被替换成执行如下的invoke方法
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Exception
    {
        DogUtil du = new DogUtil();
        // 执行DogUtil对象中的method1。
        du.method1();
        // 以target作为主调来执行method方法
        Object result = method.invoke(target , args);
        // 执行DogUtil对象中的method2。
        du.method2();
        return result;
    }
}


接下来:


public class MyProxyFactory {

    // 为指定target生成动态代理对象
    public static Object getProxy(Object target)
            throws Exception
    {
        // 创建一个MyInvokationHandler对象
        MyInvokationHandler handler =
                new MyInvokationHandler();
        // 为MyInvokationHandler设置target对象
        handler.setTarget(target);
        // 创建、并返回一个动态代理
        return Proxy.newProxyInstance(target.getClass().getClassLoader()
                , target.getClass().getInterfaces() , handler);
    }
}

测试:


public class Test {

    public static void main(String[] args)
            throws Exception
    {
        // 创建一个原始的GunDog对象,作为target
        Dog target = new GunDog();
        // 以指定的target来创建动态代理
        Dog dog = (Dog)MyProxyFactory.getProxy(target);
        dog.info();
        dog.run();
    }
}

dog对象实际是动态代理对象,只是该动态代理对象也实现了Dog接口

反射与泛型

从Java5开始允许使用泛型来限制Class类,如:String.class的类型实际上就是CLass< Sring >

泛型与Class类

使用Class< T >可以避免强制类型转换

下面创建一个简单对象工厂,该对象工厂可以根据指定类来提供该类的实例


public class CrazyitObjectFactory {

    public static Object getInstance(String clsName)
    {
        try
        {
            // 创建指定类对应的Class对象
            Class cls = Class.forName(clsName);
            // 返回使用该Class对象所创建的实例
            return cls.newInstance();
        }
        catch(Exception e)
        {
            e.printStackTrace();
            return null;
        }
    }
}

将上面的改写成使用泛型的Class:

public class CrazyitObjectFactory2 {

    public static <T> T getInstance(Class<T> cls)
    {
        try
        {
            return cls.newInstance();
        }
        catch(Exception e)
        {
            e.printStackTrace();
            return null;
        }
    }
    public static void main(String[] args)
    {
        // 获取实例后无须类型转换
        Date d = CrazyitObjectFactory2.getInstance(Date.class);
        JFrame f = CrazyitObjectFactory2.getInstance(JFrame.class);
    }
}

对Array的newInstance()进行包装

public class CrazyitArray {

    // 对Array的newInstance方法进行包装
    @SuppressWarnings("unchecked")
    public static <T> T[] newInstance(Class<T> componentType, int length)
    {
        return (T[]) Array.newInstance(componentType , length);  //①
    }
    public static void main(String[] args)
    {
        // 使用CrazyitArray的newInstance()创建一维数组
        String[] arr = CrazyitArray.newInstance(String.class , 10);
        // 使用CrazyitArray的newInstance()创建二维数组
        // 在这种情况下,只要设置数组元素的类型是int[]即可。
        int[][] intArr = CrazyitArray.newInstance(int[].class , 5);
        arr[5] = "Java";
        // intArr是二维数组,初始化该数组的第二个数组元素
        // 二维数组的元素必须是一维数组
        intArr[1] = new int[]{23, 12};
        System.out.println(arr[5]);
        System.out.println(intArr[1][1]);
    }
}

反射获取泛型信息

public class GenericTest {

    private Map<String , Integer> score;
    public static void main(String[] args)
            throws Exception
    {
        Class<GenericTest> clazz = GenericTest.class;
        Field f = clazz.getDeclaredField("score");
        // 直接使用getType()取出的类型只对普通类型的成员变量有效
        Class<?> a = f.getType();
        // 下面将看到仅输出java.util.Map
        System.out.println("score的类型是:" + a);
        // 获得成员变量f的泛型类型
        Type gType = f.getGenericType();
        // 如果gType类型是ParameterizedType对象
        if(gType instanceof ParameterizedType)
        {
            // 强制类型转换
            ParameterizedType pType = (ParameterizedType)gType;
            // 获取原始类型
            Type rType = pType.getRawType();
            System.out.println("原始类型是:" + rType);
            // 取得泛型类型的泛型参数
            Type[] tArgs = pType.getActualTypeArguments();
            System.out.println("泛型信息是:");
            for (int i = 0; i < tArgs.length; i++)
            {
                System.out.println("第" + i + "个泛型类型是:" + tArgs[i]);
            }
        }
        else
        {
            System.out.println("获取泛型类型出错!");
        }
    }

}

发布了183 篇原创文章 · 获赞 58 · 访问量 18万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览