Java学习笔记之反射机制

最新推荐文章于 2023-07-10 10:21:17 发布

曲水流觞笑醉尘

最新推荐文章于 2023-07-10 10:21:17 发布

阅读量350

点赞数

文章标签：反射 java

本文链接：https://blog.csdn.net/qq_42525761/article/details/108652729

版权

反射专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

一、反射概述

基本概念：

反射是一种机制，利用该机制可以在程序运行过程中对类进行解剖，并操作类中的方法、属性构造方法等成员；

可以理解为，反射就是创建对象，调用方法，给成员变量赋值和取值的一种方式；

反射就是通过获取到一个类的Class对象来操作里面成员数据并执行相关操作的过程；

应用场景：

开发IDE编译器（集成开发环境，比如IDEA，Eclipse）

开发框架（Spring、SpringMVC、Mybatis。。。）

学习框架

反射的前提条件：

必须先获得字节码文件对象：Class对象

获得Class对象的三种方式：

通过类名.class获取

通过对象名.getClass（）获取

通过Class.forName（“类全名字符串”）获取

public class test {

    public static void main(String[] args) throws ClassNotFoundException {
        //1.通过类名.class获取
        Class sortClass = HeapSort.class;
        //2.通过getClass()方法
        Class heap = new HeapSort().getClass();
        //通过Class.forName
        Class name = Class.forName("HeapSort");
        //由于只有一个class对象，所以上面这三种方式都会获取到同一个对象
        System.out.println(sortClass);
        System.out.println(heap);
        System.out.println(name);
    }

}

在这里插入图片描述

获取Class对象属性的方法：

public class test {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.通过类名.class获取
        Class sortClass = HeapSort.class;
        //获取类全名，因为我的项目是类是直接放在src包下的，所以类全名就是类名
        System.out.println(sortClass.getName());
        //获取类名
        System.out.println(sortClass.getSimpleName());
    }
}

在这里插入图片描述

二、反射操作构造方法

Constructor类概述：

类中的每一个构造方法都是一个Constructor类的对象，反射操作构造方法就是要获得构造方法对应的Constructor对象，然后通过该对象来创建类对象；

获得Constructor对象：

要注意，这里只能是Class对象来获得Constructor对象

//根据参数类型，获得对应的构造方法对象，只能获取到以public修饰的
Constructor getConstructor(Class... paramterTypes)
//根据参数类型，获得对应的构造方法对象，包括private
Constructor getDeclaredConstructor(Class... paramterTypes)

Constructor对象常用方法：

//根据参数创建实例对象
T newInstance(Object 。。。 args)
//设置是否可访问，是否取消权限检查，暴力反射
//true：取消权限检查，可以访问private修饰的
//false：要检查权限，默认值
//要在上面这个方法调用前使用
void setAcessible(true)

Student类：

package com.ps.pojo;

public class Student {
    private String username;
    private String password;

    public Student(String username, String password) {
        System.out.println("双参构造");
    }
    
    private Student(String username) {
        System.out.println("一个参构造");
    }

    public Student() {
        System.out.println("无参构造");
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "Student{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

test类：

package com.ps.test;

import com.ps.pojo.Student;
import org.junit.Test;
import java.lang.reflect.Constructor;

public class StuTest {

    @Test
    public void test1() throws Exception {
        Class c = Student.class;
        Constructor<Student> con = c.getConstructor();
        Student student = con.newInstance();
    }

    @Test
    public void test2() throws Exception {
        Class c = Student.class;
        Constructor<Student> con = c.getConstructor(String.class, String.class);
        Student student = con.newInstance("123", "123");
    }

    @Test
    public void test3() throws Exception {
        Class c = Student.class;
        //如果不改变方法，是获取不到private修饰的构造方法
        Constructor<Student> con = c.getDeclaredConstructor(String.class);
        //如果不加这个，就无法创造对象，对于权限不通过的构造方法，需要这样来访问
        con.setAccessible(true);
        Student student = con.newInstance("123");
    }

}

运行结果：
在这里插入图片描述

三、反射操作成员方法

Method类概述：

类中的每一个成员方法都是一个method对象，反射操作成员方法就是要获得该方法的method对象，通过调用method对象调用方法；

获得Method：

//根据方法名和参数类型获得对应的method对象，但是只能是public修饰的
Method getMethod(String methodName,Class ... args);
//和上面的方法功能一样，但是它可以private修饰的
Method getDeclaredMethod(String methodName,Class ... args);
//获得当前类的所有成员方法对象，包括父类的，但是只能是public修饰的
Method[] getMethods();
//获得当前类的所有成员方法对象，包括private修饰的，但是只能是本类的
Method[] getDeclaredMethods();

常用方法：

//执行调用的方法
//obj是这个类的对象，后面是方法需要传入的值
//前面的object是返回值
Object invoke(Object obj,Object ... args);

//取消权限检查，暴力反射
//true取消权限检查
//false检查权限
void setAcessible(true);

代码样例：

test代码：

package com.ps.test;

import com.ps.pojo.Student;
import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class StuTest {
    @Test
    public void test4() throws Exception {
        Class c = Student.class;
        Constructor constructor = c.getConstructor();
        //获得类对象
        Object stu = constructor.newInstance();
        Method method = c.getMethod("eat");
        //调用类方法
        method.invoke(stu);
    }

    @Test
    public void test5() throws Exception {
        Class c = Student.class;
        Constructor constructor = c.getConstructor();
        Object stu = constructor.newInstance();
        //设置参数类型
        Method method = c.getMethod("sleep", String.class, int.class);
        //传入参数，调用方法
        method.invoke(stu, "床上", 10);
    }

    @Test
    public void test6() throws Exception {
        Class c = Student.class;
        Constructor constructor = c.getConstructor();
        Object stu = constructor.newInstance();
        Method method = c.getDeclaredMethod("study", int.class);
        //取消权限检查
        method.setAccessible(true);
        method.invoke(stu, 10);
    }

    @Test
    public void test7() throws Exception {
        Class c = Student.class;
        Constructor constructor = c.getConstructor();
        Object stu = constructor.newInstance();
        Method[] method = c.getMethods();
        for (Method method1 : method) {
            System.out.println(method1);
        }
    }
    
    @Test
    public void test8() throws Exception {
        Class c = Student.class;
        Constructor constructor = c.getConstructor();
        Object stu = constructor.newInstance();
        Method[] method = c.getDeclaredMethods();
        for (Method method1 : method) {
            System.out.println(method1);
        }
    }
}

pojo代码：

package com.ps.pojo;

public class Student {
    private String username;
    private String password;

    public void eat(){
        System.out.println("我正在吃海鲜大餐");
    }

    public void sleep(String site,int hour){
        System.out.println("我在"+site+"睡了"+hour+"小时");
    }

    private void study(int hour){
        System.out.println("学习学了"+hour+"小时");
    }

    public Student(String username, String password) {
        System.out.println("双参构造");
    }

    private Student(String username) {
        System.out.println("一个参构造");
    }

    public Student() {
        System.out.println("无参构造");
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "Student{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

运行结果：
在这里插入图片描述

四、反射操作成员变量

Field类概述：

类中的每一个成员变量都是Field类的对象，反射操作成员变量，就是获得成员变量对应的Field对象，通过Field对象给成员变量赋值。

获得Field对象：

//其实也是有不带Declared的方法的，但是由于成员变量基本都是private修饰的
//所以几乎不会用到哪两种方式
//根据成员变量名获得Field对象，包括private修饰的
Field getDeclaredField(String name);
//获得当前类所有的成员变量对象
Field[] getDeclaredFields();
//获取属性的类型，返回class对象。
Class getType();

Field常用方法：

//获得指定对象obj对应成员变量的值
int getint(object obj)
object get (object obj)
long getLong(object obj)
boolean getBoolean(object ob)
double getDouble (object obj)    
//设置指定对象obj对应成员变量的值
void set(object obj,Object value)
void setInt (object obj, int i)
void setLong(object obj, long l)
void setBoolean (object obj, boolean z)    
void setDouble (object obj, double d)    
//和之前一摸一样的暴力反射
void setAcessible(true);

代码样例：

    @Test
    public void test9() throws Exception {
        Class c = Student.class;
        Constructor constructor = c.getConstructor();
        Object stu = constructor.newInstance();
        Field field = c.getDeclaredField("username");
        field.setAccessible(true);
        System.out.println(stu);
        field.set(stu, "207401255");
        System.out.println(stu);
        Object o = field.get(stu);
        System.out.println(o);
    }

运行结果：
在这里插入图片描述

由于和前面两个太相似了，所以就不过多赘述和演示了；

五、实现读取properties配置文件创建对象

pojo类：

和之前的没有太大区别

package com.ps.pojo;

public class Student {
    private String username;
    private String password;


    public void eat(){
        System.out.println("我正在吃海鲜大餐");
    }

    public void sleep(String site,int hour){
        System.out.println("我在"+site+"睡了"+hour+"小时");
    }

    private void study(int hour){
        System.out.println("学习学了"+hour+"小时");
    }

    public Student(String username, String password) {
        System.out.println("双参构造");
    }

    private Student(String username) {
        System.out.println("一个参构造");
    }

    public Student() {
        System.out.println("无参构造");
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "Student{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

stu.properties:（直接放在src目录下面）

class=com.ps.pojo.Student
username=ps
password=123456

主要实现：

package com.ps.pojo;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.Properties;
import java.util.Set;

public class demo {
    public static void main(String[] args) throws Exception {
    	//由于我函数中编写的是通过Class.class中的方法获取的流
    	//所以只需要把文件放到src目录下
    	//编写的之后/+文件名即可读取到数
        Student obj = (Student) getObj("/stu.properties");
       	//student类编写了toString方法，所以可以直接输出
        System.out.println(obj);
    }

    public static Object getObj(String filename) throws Exception {
        //1.创建配置信息读取类
        Properties properties = new Properties();
        //2.把配置文件读取到配置信息类的对象中
        properties.load(Class.class.getResourceAsStream(filename));
        //3.获得类全名
        Object ClassStr = properties.get("class");
        //4.获得Class对象
        Class targetClass = Class.forName((String) ClassStr);
        //5.获得构造方法对象
        Constructor constructor = targetClass.getConstructor();
        //6.反射机制调用空参构造方法
        Object obj = constructor.newInstance();
        //7.遍历集合把数据填入到对象中
        Set<String> set = properties.stringPropertyNames();
        for (String s : set) {
            //8.如果遇到class字符串则不处理
            if (s.equals("class"))
                continue;
            //9.获得成员变量对象和value值,要记得使用带有declared，不然访问不到
            Field field = targetClass.getDeclaredField(s);
            String values = properties.getProperty(s);
            //10.暴力反射
            field.setAccessible(true);
            //11.判断成员变量的类型，通过合适的类型来设置参数
            if (field.getType() == int.class) {
                field.setInt(obj, Integer.parseInt(values));
            } else if (field.getType() == double.class) {
                field.setDouble(obj, Double.parseDouble(values));
            } else if (field.getType() == boolean.class) {
                field.setBoolean(obj, Boolean.parseBoolean(values));
            } else if (field.getType() == byte.class) {
                field.setByte(obj, Byte.parseByte(values));
            } else if (field.getType() == float.class) {
                field.setFloat(obj, Float.parseFloat(values));
            } else if (field.getType() == short.class) {
                field.setShort(obj, Short.parseShort(values));
            } else if (field.getType() == long.class) {
                field.setLong(obj, Long.parseLong(values));
            } else if (field.getType() == char.class) {
            	//如果是char类型的话，就只有一个，所以直接获取即可
                field.setChar(obj, s.charAt(0));
            } else {
                field.set(obj, values);
            }
        }
        //12.返回创建好，并把成员变量也设置好的对象
        return obj;
    }
}