一些反射的总结

1.什么是反射

JAVA反射机制：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍然可以扩展

package com.chao.demo;

public class Student {
    //成员变量：一个私有，一个默认，一个公共
    private String name;
    int age;
    public String address;

    //构造方法：一个私有，一个默认，两个公共
    public Student() {
    }

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

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

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

    //成员方法：一个私有，四个公共
    private void function() {
        System.out.println("function");
    }

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

    public void method2(String s) {
        System.out.println("method:" + s);
    }

    public String method3(String s, int i) {
        return s + "," + i;
    }

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

2.获取Class类对象的三种方式

//1   类名.class
Class<Student> c1 = Student.class;


//2 2 对象.getClass()
 Student s1 = new Student();
   Class<? extends Student> c2 = s1.getClass();


//3  Class.forName(“包名.类名”)
//使用Class类中的静态方法forName，抛throws ClassNotFoundException异常
//可以将路径配置到配置文件中，灵活性较高
Class<Student> class = Class.forName("com.chao.demo.Student");

3.反射获取构造方法并使用

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

使用构造方法创建对象

T newInstance​(Object... initargs)：根据指定的构造方法创建对象
//通过公共无参构造方法创建对象
//创建class对象
Class<?> c = Class.forName("com.chao.demo.Student");
//获取公共无参构造方法
Constructor<?> c1 = c.getConstructor();
Object obj1 = c1.newInstance();

//通过公共有参构造方法创建对象
//创建class对象
Class<?> c = Class.forName("com.chao.demo.Student");
//获取公共有参构造方法
Constructor<?> c1 = c.getConstructor(String.class,int.class,String.class);
Object obj1 = c1.newInstance("wxc",22,"hebei");
System.out.println(obj1);

//通过私有有参构造方法创建对象
//当不使用反射时，用私有构造方法创建对象时，是不允许的；使用反射时，用私有的构造方法创建对象，
//需要取消访问检查
//c2.setAccessible(true);是否取消访问检查
/创建class对象
Class<?> c = Class.forName("com.chao.demo.Student");
//获取私有有参构造方法
Constructor<?> c2 = c.getDeclaredConstructor(String.class);
//是否取消访问检查
c2.setAccessible(true);
Object obj2 = c2.newInstance("wxc");
System.out.println(obj2);

4.反射获取成员变量并使用

//1 Class类获取成员变量对象的方法
    Field[] getFields​()：返回所有公共成员变量对象的数组
    Field[] getDeclaredFields​()：返回所有成员变量对象的数组
    Field getField​(String name)：返回单个公共成员变量对象
    Field getDeclaredField​(String name)：返回单个成员变量对象
//2 给成员变量进行赋值
//void set​(Object obj, Object value)：给obj对象的成员变量赋值为value
    //1. 建class对象
    Class<Student> c = Student.class;
    //2. 获取指定的类属性
    Field f1 = c.getDeclaredField("address");
    //3. 给指定对象进行赋值，需要通过构造方法创建对象，然后进行赋值
    //3.1 创建对象
    Constructor<Student> c1 = c.getConstructor();
    //3.2 实例化
    Student s = c1.newInstance();
    //3.3 进行赋值
    f1.set(s,"hebei");
    //进行输出
    System.out.println(s);

5.反射获取成员方法并使用

//1 Class类中用于获取成员方法的方法
    Method[] getMethods​()：返回所有公共成员方法对象的数组，包括继承的
    Method[] getDeclaredMethods​()：返回所有成员方法对象的数组，不包括继承的
    Method getMethod​(String name, Class<?>... parameterTypes) ：返回单个公共成员方法对象
    Method getDeclaredMethod​(String name, Class<?>... parameterTypes)：返回单个成员方法对象
//2 Method类中用于调用成员方法的方法
// Object invoke​(Object obj, Object... args)：
//调用obj对象的成员方法，参数是args,返回值是Object类型
    //1.通过无参创建对象，调用public方法
    //创建建class对象
        Class<Student> c = Student.class;
        //获取方法
        Method m = c.getMethod("method1");
        //创建对象，调用方法m
        //创建对象
        Constructor<Student> c1 = c.getConstructor();
        Student s = c1.newInstance();
        //调用方法m
        m.invoke(s);
   //2.通过无参创建对象，调用私有带参方法
        //创建建class对象
        Class<Student> c = Student.class;
        //获取方法
        Method m = c.getDeclaredMethod("function");
        //取消访问检测
        m.setAccessible(true);
        //创建对象，调用方法m
        //创建对象
        Constructor<Student> c1 = c.getConstructor();
        Student s = c1.newInstance();
        //调用方法m
        m.invoke(s);
   

6.反射，突破极限

//在ArrayList<Integer>集合中，添加字符串。
//创建集合
ArrayList<Integer> array = new ArrayList<>();
//创建Class对象
Class<? extends ArrayList> c = array.getClass();
//获取add方法
Method m = c.getMethod("add", Object.class);
//执行m（add）方法
m.invoke(array,"hello");
m.invoke(array,"world");
System.out.println(array);

7. 十分感谢
https://blog.youkuaiyun.com/wxc1207/article/details/108304190?utm_medium=distribute.pc_category.none-task-blog-hot-8.nonecase&depth_1-utm_source=distribute.pc_category.none-task-blog-hot-8.nonecase&request_id=