Java之反射机制

反射

反射：是指在程序运行期间，能够观察和修改类或者类的对象的属性和行为的特性
项目开发中常见的使用反射的场景：
①使用JDBC连接数据库
②Servlet在Web容器中的加载和运行

反射的作用：

Java反射机制提供了以下的功能
①在运行时获取类的修饰符，包名，类名，实现的接口，继承的父类
②在运行时获取类的所有属性名，修饰符，属性类型
③在运行时获取所有方法，方法的返回值类型，方法名，方法参数数量，方法参数类型
④在运行时调用加载类的方法

Java反射API常用的类

①java.lang.Class
②java.lang.reflect.Method
③java.lang.Constructor
④java.lang.Field
⑤java.lang.Modifier

反射使用示例

首先我们先新建一个类，我们对类的访问修饰符稍微修改，接下来都会以对这个类操作为例

// 新建Student类
public class Student {
    public int id;
    private String name;
    String sex;

    private Student() {
    }

    private Student(int id, String name, String sex) {
        this.id = id;
        this.name = name;
        this.sex = sex;
    }

    private int getId() {
        return id;
    }

    private void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

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

①使用Java反射获取类的信息
获取类的信息方式有三种，下面为大家一一介绍

// 新建Test类
public class TestStudent<T> {
    public static void main(String[] args){
    	// 方式一:实例化一个对象，通过对象.getClass()获取信息
    	Test t = new Test();
    	Class c = t.getClass();
    	// 方式二: 通过类名.class获取
    	Class<Student> stu = Student.class;
    	// 方式三: 通过Class.forName(类全路径)获取
        Class stu = Class.forName("demo.Student");
    }

②使用Java反射获取类的构造函数的参数列表，并通过构造函数实例化类
由于Student类的构造方法为私有的，故通过new的方式无法实例化对象，下面为读者介绍获取Student的操作

public class TestStudent<T> {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, ClassNotFoundException {
        TestStudent ts = new TestStudent();
        Student student = (Student) ts.getObject("demo.Student");
        student.id = 1;
        student.sex = "男";
        student.setName("张三");
        System.out.println(student);
    }
    // 泛型方式获取Student对象，参数为类全路径
    public T getObject(String classPath){
        T t = null;
        try {
        	// 通过类路径获取类信息
            Class<T> tClass = (Class<T>) Class.forName(classPath);
            // getDeclaredConstructor()方法可以获取对象私有化的构造器（包括其他类型的）
            Constructor<T> c = tClass.getDeclaredConstructor();
            // 构造方法为private时，要通过 setAccessible(boolean flag)方法获取访问权限，默认为false，我们将参数设为true即可获取权限
            c.setAccessible(true);
            // newInstance()创建对象
            t = c.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return t;
    }
    // 跟上一个方法类似，只是参数直接传递的是类的信息
    public T getObject2(Class<T> tClass){
        T t = null;
        try {
            Constructor<T> c = tClass.getDeclaredConstructor();
            c.setAccessible(true);
            t = c.newInstance();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return t;
    }
    // 指定类型，获取Student对象
    public static Student getStudent(){
        Class<Student> s = Student.class;
        Student stu = null;
        try {
            Constructor<Student> c = s.getDeclaredConstructor();
            c.setAccessible(true);
            stu = c.newInstance();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return stu;
    }
}

③使用Java反射获取类的所有方法的信息，并调用类的setter方法进行属性的赋值

public class TestMethod {
    public static void main(String[] args) throws Exception {
    	// 调用TestStudent静态方法获取Student对象
        Student stu = TestStudent.getStudent();
       	// 获取类信息
        Class<Student> c = Student.class;
        // 这里跟构造器的区别是构造器用Constructor，方法用Method
        // getDeclareMethod方法第一个参数为要获取的方法名,后面为方法参数列表的类信息,多个参数可通过,参数类型.class分隔
        Method setId = c.getDeclaredMethod("setId", int.class);
        // 私有化方法要设设置
        setId.setAccessible(true);
        // invoke调用方法,第一个参数要调用的方法的具体对象,后面为要设置的参数值
        setId.invoke(stu,3);
        // 带返回值的方法
        Method getId = c.getDeclaredMethod("getId");
        getId.setAccessible(true);
        // 设置接收返回值
        Object obj = getId.invoke(stu);
        System.out.println(stu);
        System.out.println(obj);
    }
}

④使用Java反射获取类的所有属性的名称和类型，并为其中一个属性赋值

public class TestField {
    public static void main(String[] args) throws Exception{
   	 	// 调用TestStudent静态方法获取Student对象
        Student stu = TestStudent.getStudent();
        // 获取类信息
        Class<Student> c = Student.class;
        // 属性用Field
        // getField方法参数为要获取的属性名
        Field id = c.getField("id");
        // set方法用于赋值，第一个参数为要赋值属性的具体对象,第二个为要赋的值
        id.set(stu,5);
        Field name = c.getDeclaredField("name");
        // 私有属性要设置访问权限
        name.setAccessible(true);
        name.set(stu,"王五");
        // getDeclaredFields获取全部属性,返回值为Field类型数组
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            System.out.println(field.get(stu));
        }
    }
}