什么是反射

一、为什么要学习反射？🌹

 我们之前创建对象，是通过new的方式。这样创建对象会导致繁琐、耦合度高、复用性差。

      举个通俗的例子：我们想去吃个牛排大餐，如果我们自己创建，什么都要管理。屠宰你管，运输你管，冷藏你管，烹饪你管，上桌你也要管。就拿做菜来说，你能有大厨做得好？

那怎么办呢？有句话说的好，专业的事情交个专业的人做，屠宰交个刽子手，运输交给物流，烹饪交个厨师。那我们干嘛呢，坐着等吃不就好了！

二、什么是反射？⭐

注：反射并不是二十三中设计模式

          反射是一种编程语言的特性，指的是在运行时动态地获取、检查和修改程序结构（如类、对象、方法、属性等）的能力。通过反射，程序可以在运行时获取对象的类型信息、调用对象的方法、访问对象的属性等。

Java的反射机制是在编译并不确定是哪个类被加载了，而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类。这样的特点就是反射，体现了Java的动态性。

每一个类都会在编译之后都会产生.class文件，当这个类在第一次使用的时候类加载器(ClassLoader)会加载.class到jvm中，

加载：由类加载器完成，找到对应的字节码，创建一个Class对象

链接：验证类中的字节码，为静态域分配空间

初始化：如果该类有超类，则对其初始化，执行静态初始化器和静态初始化块（编译器将检查类型向下转型是否合法，如果不合法将抛出异常。向下转换类型前，可以使用instanceof判断。）

 1、怎么使用反射

•  第一步：首先要有一个目标类（用来验证反射）

//在类中有私有变量和共有变量 私有构造和共有构造
public class User {
 
    public String address;
    private int id;
    private String name;
 
 
    public User() {
        System.out.println("无参构造");
    }
 
    public User(int id, String name) {
        System.out.println("全部参数构造");
        this.id = id;
        this.name = name;
    }
 
    private User(int id) {
        System.out.println("私有id的构造函数");
        this.id = id;
    }
 
    private int add(int a){
        System.out.println("私有方法");
        int i=10;
        return a+i;
    }
 
 
    public int add1(int a){
        System.out.println("共有方法");
        int i=10;
        return a+i;
    }
 
    public static int add2(int a){
        System.out.println("静态方法");
        int i=10;
        return a+i;
    }
 
    @Override
    public String toString() {
        return "User{" +
                "address='" + address + '\'' +
                ", id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

• 第二步：我们使用反射得到类（反射得到类有三种方式，第三种实用性强）
  

@org.junit.Test
    public void t1() throws ClassNotFoundException {
        System.out.println("第一种获取反射类 new 对象,对象.class");
        User user = new User();
        Class c1 = user.getClass();
        System.out.println(c1);
 
        System.out.println("第二种获取反射类 类.class");
        Class c2 = User.class;
        System.out.println(c2);
 
        System.out.println("第三种获取反射类 Class.forName(全限定名字)");
        Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");
        System.out.println(c3);
 
        System.out.println("反射类只有一个 所以都相等 但是创建的对象不相等");
        System.out.println(c1 == c2);//true
        System.out.println(c2 == c3);//true
 
 
    }

• 第三步：通过得到类获取构造函数创建对象、获取字段、获取方法

/**
     * 反射获取类 类通过构造得到对象
     *
     * @throws ClassNotFoundException
     */
    @org.junit.Test
    public void t2() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
 
 
        System.out.println("第三种获取反射类");
        Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");
 
        //获取所有的public的方法
        System.out.println("=============getConstructors获取所有public构造=================");
        Constructor[] constructors = c3.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println("所有的public构造：" + constructor);
        }
        System.out.println();
 
 
        //获取指定的public的方法
        System.out.println("=============getConstructor获取指定public构造=================");
        Constructor constructorsP = c3.getConstructor(null);
        Constructor constructorsP1 = c3.getConstructor(int.class, String.class);
 
        //实例化对象 无参构造不能写参数constructorsP.newInstance(1,"22");
        User user = constructorsP.newInstance();
        System.out.println(user);//输出对对象
        System.out.println(user.add1(2));//调用方法
 
        User user1 = constructorsP1.newInstance(1, "郑州");
        System.out.println(user1);
        System.out.println(user1.add1(3));
 
 
        System.out.println("公有无参构造：" + constructorsP);
        System.out.println("公有两个参数构造：" + constructorsP1);
 
        System.out.println();
 
 
        //获取所有的public,private的方法
        System.out.println("=============getDeclaredConstructors获取所有public，private构造=================");
        Constructor[] constructors1 = c3.getDeclaredConstructors();
        for (Constructor constructor : constructors1) {
            System.out.println("所有的public、peivate构造：" + constructor);
        }
        System.out.println();
 
 
        //获取指定的的private的方法
        System.out.println("=============getDeclaredConstructor获取private构造=================");
        Constructor constructors11 = c3.getDeclaredConstructor(int.class);
        System.out.println("私有一个参数构造：" + constructors11);
 
        System.out.println();
 
        System.out.println(c3);
 
 
    }
 
 
    /**
     * 反射获取类 类获取到字段
     *
     * @throws ClassNotFoundException
     */
    @org.junit.Test
    public void t3() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
 
 
        System.out.println("第三种获取反射类");
        Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");
 
        //获取无参构造 并且创建对象
        Constructor userConstructor = c3.getConstructor(null);
        User user = userConstructor.newInstance();
 
        System.out.println("");
        System.out.println("===========getFields获取所有的共有字段===========");
        Field[] fields = c3.getFields();
        for (Field field : fields) {
            field.set(user, "北京");
            System.out.println(field);
        }
        System.out.println("私有属性的User:" + user);
 
 
        System.out.println();
        System.out.println("===========getDeclaredFields获取所有的字段(public private)===========");
        Field[] fields1 = c3.getDeclaredFields();
        for (Field field : fields1) {
            System.out.println(field);
        }
 
        System.out.println();
        System.out.println("===========getDeclaredField获取私有和共有  getField获取共有的指定字段===========");
 
        Field field = c3.getDeclaredField("id");
        field.setAccessible(true);
        field.set(user, 1);
        field = c3.getDeclaredField("name");//获取私有
        field.setAccessible(true);//设置true 才能这设置值
        field.set(user, "麻子");
 
        field = c3.getDeclaredField("address");//获取共有
        field.set(user, "天津");
 
        System.out.println(user);
 
 
    }
 
 
    /**
     * 反射获取类 类获取到方法
     *
     * @throws ClassNotFoundException
     */
    @org.junit.Test
    public void t4() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
 
 
        System.out.println("第三种获取反射类");
        Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");
 
        System.out.println("============反射构造函数，然后实例化对象============");
        User user = (User) c3.getConstructor(int.class, String.class).newInstance(1, "大大");
        User user1 = (User) c3.getConstructor(int.class, String.class).newInstance(1, "大大");
 
        System.out.println(user == user1);
 
        System.out.println();
        System.out.println("============getMethods反射获取public方法，包含父类object的方法===========");
        Method[] methods = c3.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
 
        System.out.println();
        System.out.println("============getMethod反射获取指定的public方法，包含父类object的方法===========");
        Method m1 = c3.getMethod("add2", int.class);
        System.out.println("方法返回值+10："+m1.invoke(user, 3));
 
 
        System.out.println();
        System.out.println("============getDeclaredMethods反射获取public和private方法 只有自己的============");
        Method[] methods1 = c3.getDeclaredMethods();
        for (Method method : methods1) {
            System.out.println(method);
        }
 
 
        System.out.println();
        System.out.println("============getDeclaredMethod反射获取public和private方法 只有自己的============");
        Method m2 = c3.getDeclaredMethod("add",int.class);
        m2.setAccessible(true);
        System.out.println("方法返回值+10："+m2.invoke(user1,5));
 
        m2=c3.getDeclaredMethod("add1",int.class);
        System.out.println("方法返回值+10："+m2.invoke(user1,11));
 
 
    }