Java之反射

最新推荐文章于 2022-09-03 23:21:13 发布

一株禾

最新推荐文章于 2022-09-03 23:21:13 发布

阅读量104

点赞数 1

分类专栏： Java 文章标签： java 开发语言缓存

本文链接：https://blog.csdn.net/chuhe163/article/details/124391786

版权

Java 专栏收录该内容

37 篇文章 3 订阅

订阅专栏

文章目录

1、类加载器
- 1.1、类加载
- 1.2、类加载器
2、反射

1、类加载器

1.1、类加载

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过类的加载、类的连接、类的初始化三个步骤来对类进行初始化。如果不出现意外情况，JVM将会连续完成这三个步骤，所以有时也把这三个步骤称为类加载或者类初始化。

类的加载

就是指将class文件读入内存，并为之创建一个java.lang.Class对象。
任何类被使用时，系统都会为之建立一个java.lang.Class对象。

类的连接

验证阶段：用于检验被加载的类是否有正确的内部结构，并和其他类协调一致。
准备阶段：负责为类的类变量分配内存，并设置默认初始化值。
解析阶段：将类的二进制数据中的符号引用替换为直接引用。

类的初始化

该阶段，主要是对类变量进行初始化。

类的初始化步骤：

假如类还未被加载和连接，则程序先加载并连接该类。
假如该类的直接父类还未被初始化，则选初始化其直接父类。
假如类中有初始化语句，则系统依次执行这些初始化语句。

注意：在执行第2个步骤时，系统对直接父类的初始化步骤也遵循初始化步骤。

类的初始化时机：

创建类的实例
调用类的类方法
访问类或者接口的类变量，或者为该类变量赋值。
使用反射方式来强制创建某个类或接口对应的java.lang.Class对象。
初始化某个类的子类。
直接使用java.exe命令来运行某个主类。

1.2、类加载器

类加载器的作用：

负责将.class文件加载到内存中，并为之生成对应的java.lang.Class对象。
虽然不用过分关心类加载机制，但了解这个机制我们就能更好的理解程序的运行。

JVM的类加载机制：

全盘负责：当一个类加载器负责加载某个Class时，该Class所依赖和引用的其他Class也将由该类加载器负责载入，除非显示使用另外一个类加载器一载入。
父类委托：当一个类加载器负责加载某个Class时，先让父类加载器加载该Class，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类。
缓存机制：保证所有加载过的Class都会被缓存，当程序需要使用使用某个Class对象时，类加载器先从缓存区中搜索该Class，只有当缓存区中不存在该Class对象时，系统才会读取该类对应的二进制数据，并将其转换成Class对象，存储到缓存区。

ClassLoader：是负责加载类的对象

java运行时具有以下内置类加载器：

Bootstrap class loader：它是虚拟机的内置类加载器，通常表示为null,并且没有父null
Platform class loader：平台类加载器可以看到所有平台类，平台类包括由平台类加载器或其祖先定义的Java SE平台API，其实现类和JDK特定的运行时类。
System class loader：它了被称为应用程序类回呀载器，与平台类加载器不同。系统类加载器通常用于定义应用程序类路径，模块路径和JDK特定工具上的类。
类加载器的继承关系：System的父加载器为Platform，而Platform的父加载器为Bootstrap。

ClassLoader中的两个方法：

static ClassLoader getSystemClassLoader()：返回用于委派的系统类加载器。
ClassLoader getParent()：返回父类加载器进行委派。

package com.test;

public class Demo {
    public static void main(String[] args) {
        //返回用于委派的系统类加载器
        ClassLoader c1 = ClassLoader.getSystemClassLoader();//AppClassLoader
        System.out.println(c1);

        //返回父类加载器进行委派
        ClassLoader c2 = c1.getParent();//PlatformClassLoader
        System.out.println(c2);

        ClassLoader c3 = c2.getParent();//null
        System.out.println(c3);

    }
}

2、反射

2.1、反射概述

Java反射机制：是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍可以扩展。
在这里插入图片描述

2.2、获取Class类的对象

要想通过反射去使用一个类，首先我们要获取到该类的字节码文件对象，也就是类型为Class类型的对象。

三种方式获取Class类型的对象

使用类的class属性来获取该类对应的Class对象。如Student.class将返回Student类对就原Class对象。
调用对象的getClass()方法，返回该对象所属类对应的Class对象。
该方法是Object类中的方法，所有的Java对象都可以调用该方法。
使用Class类中的静态方法forName(String className)，该方法需要传入字符串参数，该字符串参数的值是某个类的全路径，也就是完整包名的路径。

package com.test1;

public class Student {

}

package com.test1;

public class Demo {
    public static void main(String[] args) throws ClassNotFoundException {
        //使用类的class属性来获取该类对应的class对象
        Class<Student> c1 = Student.class;
        System.out.println(c1);

        Class<Student> c2=Student.class;
        System.out.println(c1==c2);//true
        System.out.println("************");

        //调用getClass()方法，返回该对象所属类对应的class对象
        Student s=new Student();
        Class<? extends Student> c3 = s.getClass();
        System.out.println(c1==c3);//true
        System.out.println("***********");

        //使用Class类中的静态方法forName(String className)
        Class<?> c4 = Class.forName("com.test1.Student");
        System.out.println(c1==c4);//true

    }
}

2.3、反射获取构造方法并使用

Class类中用于获取构造方法的方法：

Constructor<?>[] getConstructors()：返回所有公共构造方法对象的数组。
Constructor<?>[] getDeclaredConstructors()：返回所有构造方法对象的数组。
Constructor<T> getConstructor(Class<?>... parameterTypes)：返回单个公共构造方法对象
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)：返回单个构造方法对象。

package com.test2;

public class Student {
    private String name;
    private int age;
    private String address;

    public Student() {
    }

    public Student(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    private Student(String name) {
        this.name = name;
    }

    Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    private void function(){
        System.out.println("function");
    }

    public void method(){
        System.out.println("method");
    }


}

package com.test2;


import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Demo {
    public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
        test1();
        System.out.println("*********");
        test2();
        System.out.println("*********");
        test3();

    }

    private static void test1() throws ClassNotFoundException {
        //获取Class对象
        Class<?> c=Class.forName("com.test2.Student");

        /*
        * Constructor<?>[] getConstructors()
        * 返回一个包含 Constructor对象的数组， Constructor对象反映了由该 Class对象表示的类的所有公共构造函数。
        * */
        Constructor<?>[] cons = c.getConstructors();
        for(Constructor  con:cons){
            System.out.println(con);
        }
    }

    private static void test2() throws ClassNotFoundException {
        //获取Class对象
        Class<?> c=Class.forName("com.test2.Student");

        /*
         *  Constructor<?>[] getDeclaredConstructors()
         * 返回反映由该 Class对象表示的类声明的所有构造函数的 Constructor对象的数组。
         */

        Constructor<?>[] cons = c.getDeclaredConstructors();
        for(Constructor con:cons){
            System.out.println(con);
        }
    }

    private static void test3() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //获取Class对象
        Class<?> c=Class.forName("com.test2.Student");

        /*
         * Constructor<T> getConstructor(Class<?>... parameterTypes) 返回一个 Constructor对象，该对象反映由该 Class对象表示的类的指定公共构造函数。
         * Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 返回一个 Constructor对象，该对象反映由此 Class对象表示的类或接口的指定构造函数。
         *
        * 参数：要获取的构造方法的参数的个数和数据类型对应的字节码文件对象
        * */
        Constructor<?> con=c.getConstructor();//获取无参构造函数

        //T newInstance(Object... initargs) 使用由此 Constructor对象表示的构造函数，使用指定的初始化参数来创建和初始化构造函数的声明类的新实例。
        Object obj=con.newInstance();//用无参构造函数创建实例
        System.out.println(obj);
        //Student s=new Student();
        //System.out.println(obj);
    }
}

2.4、反射获取构造方法案例

package com.test3;

public class Student {
    private String name;
    private int age;
    private String address;

    public Student() {
    }

    public Student(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    private Student(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

package com.test3;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Demo {
    public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
        test1();
        test2();
    }

    private static void test1() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //获取Class对象
        Class<?> c = Class.forName("com.test3.Student");

        //Constructor<T> getConstructor(Class<?>... parameterTypes)：返回单个公共构造方法对象
        Constructor<?> con = c.getConstructor(String.class, int.class, String.class);

        //创建实例对象
        Object obj = con.newInstance("唐青枫", 20, "水龙吟");
        System.out.println(obj);


    }

    private static void test2() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //获取Class对象
        Class<?> c=Class.forName("com.test3.Student");

        Constructor<?> con=c.getDeclaredConstructor(String.class);

        //暴力反射
        //public void setAccessible(boolean flag):值为true，取消访问检查
        //private Student(String name)为私有构告方法，本不能在外部构造对象
        con.setAccessible(true);
        Object obj=con.newInstance("唐青枫");
        System.out.println(obj);
    }
}

基本数据类型也可以通过.class得到对应的Class类型
public void setAccessible(boolean flag):值为true，取消访问检查

2.5、反射获取成员变量并使用

Class类中用于获取成员变量的方法：

Field getField(String name) 返回一个 Field对象，该对象反映由该 Class对象表示的类或接口的指定公共成员字段。
Field[] getFields() 返回一个包含 Field对象的数组， Field对象反映由该 Class对象表示的类或接口的所有可访问的公共字段。
Field getDeclaredField(String name) 返回一个 Field对象，该对象反映由该 Class对象表示的类或接口的指定声明字段。
Field[] getDeclaredFields() 返回一个 Field对象的数组，反映了由该 Class对象表示的类或接口声明的所有字段。

Field类中用于给成员变量赋值的方法：

void set(Object obj, Object value) 将指定的对象参数中由此 Field对象表示的字段设置为指定的新值。

package com.test4;

public class Student {
    private String name;
    int age;
    public String address;

    public Student() {
    }

    public Student(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    private Student(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

package com.test4;

import com.sun.security.jgss.GSSUtil;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

public class Demo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        test01();
        test02();
    }

    private static void test01() throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //获取Class对象
        Class<?> c=Class.forName("com.test4.Student");
        Field[] fields=c.getFields();//返回所有公共成员变量对象的数组
        for(Field field:fields){
            System.out.println(field);
        }
        System.out.println("*********************");

        //返回单个公共成员变量对象
        Field field=c.getField("address");
        System.out.println(field);
        System.out.println("*********************");

        //返回单个成员变量对象
        field=c.getDeclaredField("address");
        System.out.println(field);
        field=c.getDeclaredField("name");
        System.out.println(field);
        field=c.getDeclaredField("age");
        System.out.println(field);
        System.out.println("*********************");

        //给成员变量赋值
        Constructor<?> con = c.getDeclaredConstructor();
        con.setAccessible(true);
        Object obj=con.newInstance();
        Field fieldAddress=c.getDeclaredField("address");
        fieldAddress.set(obj,"水龙吟");
        System.out.println(obj);
        System.out.println("*********************");

    }

    private static void test02() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        //获取Class对象
        Class<?> c = Class.forName("com.test4.Student");
        //获取无参构造函数
        Constructor<?> con = c.getConstructor();
        con.setAccessible(true);
        Object obj = con.newInstance();
        Field fieldName=c.getDeclaredField("name");
        Field fieldAge=c.getDeclaredField("age");
        Field fieldAddress=c.getDeclaredField("address");
        
        //暴力反射，因为类中有些变量为private
        fieldName.setAccessible(true);
        fieldAge.setAccessible(true);
        fieldAddress.setAccessible(true);

        fieldName.set(obj,"唐青枫");
        fieldAge.set(obj,20);
        fieldAddress.set(obj,"水龙吟");
        System.out.println(obj);

    }
}

2.6、反射获取成员方法并使用

package com.test5;

import com.sun.security.jgss.GSSUtil;

public class Student {
    public static void method1(){
        System.out.println("mehtod1方法被调用");
    }

    public static void method2(String name){
        System.out.println("method2方法被调用："+name);
    }

    public static String method3(String name,int age) {
        System.out.println("method3被调用：" + name + age);
        return name + age;
    }

    private static void method4(){
        System.out.println("私有方法method4被调用");
    }

}

package com.test5;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Demo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
       //获取Class对象
        Class<?> c = Class.forName("com.test5.Student");
        //用反射获取无参构造函数
        Constructor<?> con = c.getConstructor();
        //创建实例
        Object obj = con.newInstance();
        //获取method1方法
        Method m1=c.getMethod("method1");
        //调用method1方法
        m1.invoke(obj);
        
        //调用method2方法
        //public static void method2(String name)
        Method m2=c.getMethod("method2",String.class);
        m2.invoke(obj,"唐青枫");
        
        //调用method3方法
        Method m3=c.getMethod("method3",String.class,int.class);
        Object o = m3.invoke(obj,"唐青枫",20);
        System.out.println(o);

        //调用method4方法
        //private static void method4(),这个方法是私有的
        Method m4=c.getDeclaredMethod("method4");
        m4.setAccessible(true);
        m4.invoke(obj);
    }
}

2.7、反射越过泛型检查

package com.test6;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

public class Demo {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        ArrayList<Integer> list=new ArrayList<Integer>();
        list.add(10);
        list.add(20);

        Class<? extends ArrayList> c = list.getClass();
        Method m = c.getMethod("add", Object.class);
        m.invoke(list,"hello");
        m.invoke(list,"word");
        System.out.println(list);

    }
}

2.8、通过配置文件运行类中的方法

package com.test7;

public class Student {
    public void study(){
        System.out.println("Student中的study被调用");
    }
}

package com.test7;

public class Teacher {
    public void teach(){
        System.out.println("Teacher中的teach被调用");
    }
}

根据配置文件，决定程序运行类中的方法
class.txt

className=com.test7.Student
methodName=study

package com.test7;

import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

public class Demo {
    public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //加载数据
        Properties prop=new Properties();
        FileReader fr=new FileReader("class.txt");
        prop.load(fr);
        fr.close();

        String className = prop.getProperty("className");
        String methodName=prop.getProperty("methodName");

        //通过反射使用
        Class<?> c = Class.forName(className);
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        Method method = c.getMethod(methodName);
        method.invoke(obj);

    }
}