JavaSE | 反射机制(反射Class)

✅作者简介：一位材料转码农的选手，希望一起努力，一起进步！
📃个人主页：@每天都要敲代码的个人主页

🔥系列专栏：JavaSE从入门到精通
💬推荐一款模拟面试、刷题神器，从基础到大厂面试题👉点击跳转刷题网站进行注册学习

一：反射机制概述

1、反射机制有什么用？
通过java语言中的反射机制可以操作字节码文件。
优点类似于黑客。（可以读和修改字节码文件。）
通过反射机制可以操作代码片段。（class文件。）
2、反射机制的相关类在哪个包下？
java.lang.reflect.*;
3、反射机制相关的重要的类有哪些？
java.lang.Class：代表整个字节码，代表一个类型，代表整个类。
java.lang.reflect.Method：代表字节码中的方法字节码。代表类中的方法。
java.lang.reflect.Constructor：代表字节码中的构造方法字节码。代表类中的构造方法
java.lang.reflect.Field：代表字节码中的属性字节码。代表类中的成员变量（静态变量+实例变量）。

   // java.lang.Class：（整个是一个class）
            public class User{
                // Field （成员变量）
                int no;

                // Constructor（构造方法）
                public User(){
                
                }
                public User(int no){
                    this.no = no;
                }
 

                // Method（方法）
                public void setNo(int no){
                    this.no = no;
                }
                public int getNo(){
                    return no;
                }
            }

二：反射Class

1. 获取Class的三种方式

要操作一个类的字节码，需要首先获取到这个类的字节码，怎么获取java.lang.Class实例？
三种方式：
第一种：Class c = Class.forName("完整类名带包名");
1、静态方法
2、方法的参数是一个字符串。
3、字符串需要的是一个完整类名。
4、完整类名必须带有包名。java.lang包也不能省略。
第二种：Class c = 对象（引用）.getClass();
第三种：Class c = 任何类型.class;

package com.bjpowernode.java.reflect;

import java.util.Date;

public class ReflectTest01 {
    public static void main(String[] args) {

        // 第一种方式：Class.forName()
        Class c1 = null;
        Class c2 = null;
        try {
            // c1代表String.class文件，或者说c1代表String类型。
            c1 = Class.forName("java.lang.String"); 
            // c2代表Date类型
            c2 = Class.forName("java.util.Date"); 
            // c3代表Integer类型
            Class c3 = Class.forName("java.lang.Integer"); 
            // c4代表System类型
            Class c4 = Class.forName("java.lang.System");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        // 第二种方式：对象.getClass()
        // java中任何一个对象都有一个方法：getClass()
        String s = "abc";
        // x代表String.class字节码文件；x代表String类型
        Class x = s.getClass(); 
        // true（==判断的是对象的内存地址）
        System.out.println(x == c1); 

        Date time = new Date();
        Class y = time.getClass();
        // true (c2和y两个变量中保存的内存地址都是一样的，都指向方法区中的字节码文件)
        System.out.println(c2 == y); 

        // 第三种方式，java语言中任何一种类型，包括基本数据类型，它都有.class属性。
        // z代表String类型
        Class z = String.class;
        // k代表Date类型 
        Class k = Date.class; 
        // f代表int类型
        Class f = int.class; 
        // e代表double类型
        Class e = double.class; 
        System.out.println(c1 == x && x == z); // true

    }

}

2. 通过反射实例化(创建)对象

（1）获取到Class，通过Class的newInstance()方法来实例化（创建）对象。
（2）newInstance()方法内部实际上调用了无参数构造方法，必须保证无参构造存在才可以；所以一旦我们写上了有参构造方法，无参构造方法也要写上！ 如果有有参构造方法，而没有写无参构造方法会出现异java.lang.InstantiationException 实例化异常

package com.bjpowernode.java.reflect;

import com.bjpowernode.java.bean.User;

public class ReflectTest02 {
    public static void main(String[] args) {

        // 第一种方法创建对象：不使用反射机制
        User user = new User();
        System.out.println(user);

        // 第二种方法创建对象：以反射机制的方式创建对象。（这种方式比较灵活）
        try {
            // 通过反射机制，获取Class，通过Class来实例化（创建）对象
            Class c = Class.forName("com.bjpowernode.java.bean.User");
            Object obj = c.newInstance();
           
            System.out.println(obj);
            /*
            执行结果：
                无参数构造方法
                com.bjpowernode.java.bean.User@4554617c
            */
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
}

package com.bjpowernode.java.bean;

public class User {
    // 无参构造（不写也行，默认会有）
    public User() {
        System.out.println("无参数构造方法");
    }

    // 有参构造写了，无参构造必须写；不然调用newInstance()会出现异常
    public User(String s) {
        System.out.println("无参数构造方法");
    }

}

3. 通过读配置属性文件实例化对象

（1）通过读配置属性文件实例化对象，java代码写一遍，再不改变java源代码的基础之上，只改变配置文件，可以做到不同对象的实例化；非常之灵活。（符合OCP开闭原则：对扩展开放，对修改关闭）

（2）配置文件写好，命名为xxx.properties，然后使用IO流+Properties

（3）后期我们要学习的是高级框架，而工作过程中，也都是使用高级框架，
包括： ssh ssm
Spring SpringMVC MyBatis
Spring Struts Hibernate
...
这些高级框架底层实现原理：都采用了反射机制。所以反射机制很重要的；学会了反射机制有利于我们理解剖析框架底层的源代码。

package com.bjpowernode.java.reflect;

import java.io.FileReader;
import java.util.Properties;

public class ReflectTest03 {
    public static void main(String[] args) throws Exception {
        // IO流+Properties集合
        // 通过IO流读classinfo.properties配置文件
        // 配置文件内容是：className=com.bjpowernode.java.bean.User
        FileReader reader = new FileReader("day08\\classinfo.properties");
        // 创建属性类对象Map，properties的key和value都是String
        Properties pro = new Properties();
        // 加载
        pro.load(reader);
        // reader关闭流
        reader.close();
        // 通过key获取value
        String s = pro.getProperty("className");
        //System.out.println(s); // com.bjpowernode.java.bean.User

        // 最后在通过反射机制实例化对象
        Class c = Class.forName(s);
        Object obj = c.newInstance();
        System.out.println(obj);
        /*
        执行结果：
            无参数构造方法
            com.bjpowernode.java.bean.User@4554617c
        */

        // 怎么体现灵活性？
        // 这里的代码我们都不改变，只改变classinfo.properties配置文件
        // 例如改成：className=java.util.Date
        // 此时执行的结果就变了：Wed Aug 03 15:40:02 CST 2022

    }
}

4. 只让静态代码块执行

Class.forName()执行发生了什么

（1）Class.forName("完整类名");这个方法的执行会导致类加载，类加载时，静态代码块执行。如果你只是希望一个类的静态代码块执行，其它代码一律不执行，使用Class.forName()

package com.bjpowernode.java.reflect;

public class ReflectTest04 {
    public static void main(String[] args) {
        try {
            // Class.forName()这个方法的执行会导致：类加载。
            // 类加载，静态代码块就会执行
            Class.forName("com.bjpowernode.java.reflect.MyClass");
            // 执行结果：MyClass类的静态代码块执行了！
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class MyClass{
    // 静态代码块在类加载时执行，并且只执行一次
    static{
        System.out.println("MyClass类的静态代码块执行了！");
    }
}

5. 获取类路径下文件的绝对路径

（1）怎么获取一个文件的绝对路径。以下讲解的这种方式是通用的。但前提是：文件需要在类路径(src)下才能用这种方式。

（2） 例如：

 String path = Thread.currentThread().getContextClassLoader()
               .getResource("User.properties").getPath();

    Thread.currentThread() 当前线程对象
     getContextClassLoader() 是线程对象的方法，可以获取到当前线程的类加载器对象。
     getResource() 【获取资源】这是类加载器对象的方法，当前线程的类加载器默认从类的根路径下加载资源。

    getPath() 获取路径

package com.bjpowernode.java.reflect;

import java.io.FileReader;

// 研究一下文件路径的问题
public class AboutPath {
    public static void main(String[] args) throws Exception {
        // 我们写成下面这种路径形式，只能在IDEA工具中才能找到，不够通用！
        FileReader reader = new FileReader("day08\\classinfo.properties");

        // 通用的一种方式：
        // 注意：使用以下通用方式的前提是：这个文件必须在类路径下。
        // 什么类路径下？方式在src下的都是类路径下。【src是类的根路径】

        //Thread.currentThread() 当前线程对象
        //getContextClassLoader() 是线程对象的方法，可以获取到当前线程的类加载器对象。
        //getResource() 【获取资源】这是类加载器对象的方法，当前线程的类加载器默认从类的根路径下加载资源。
        // 写成下面这种形式，放到Linux环境下也是没问题的
        // 假设classinfo.properties刚好在src下
        String path = Thread.currentThread().getContextClassLoader()
                .getResource("classinfo.properties").getPath();
        // 拿到绝对路径
        System.out.println(path); // C:/Users/86177/IdeaProjects/JavaSe1/out/production/day08/classinfo.properties

        // 假设有一个example文件没有直接在src下面，而是bean下面（com/bjpowernode/java/bean/example）
        String path2 = Thread.currentThread().getContextClassLoader()
                .getResource("com/bjpowernode/java/bean/example").getPath();
        // 获取绝对路径
        System.out.println(path2); // C:/Users/86177/IdeaProjects/JavaSe1/out/production/day08/com/bjpowernode/java/bean/example
    }
}

这样我们就可以修改原来的代码，得到更加通用的方式！

  **  第一种：先通过相对路径**（这里的相对路径前提：一定是在src下的才可以；在模块下的就不行）获取绝对路径，然后创建流：

// 1.得到相对路径
String path =Thread.currentThread().getContextClassLoader().getResource("相对路径").getPath(); 
// 2.创建流
 FileReader reader = new FileReader(path);

   ** 第二种方式：直接返回一个流（InputStream）**

InputStream reader = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("com/bjpowernode/java/bean/example");

注意：这两种方式还是还是使用IO流+properties集合的方式，使用绝对路径而不是相对路径更加的通用：

            第一种方式先得到绝对路径，返回String，然后在创建IO流

            第二种方式直接返回的就是一个流InputStream

package com.bjpowernode.java.reflect;

import java.io.FileReader;
import java.io.InputStream;
import java.util.Properties;

public class ReflectTest05 {
    public static void main(String[] args) throws Exception {
         // 第一种方式：先拿到绝对路径，然后创建流
          //还是以example为例（className=java.util.Date），先拿到绝对路径
        String path = Thread.currentThread().getContextClassLoader()
                .getResource("com/bjpowernode/java/bean/example").getPath();
        FileReader reader = new FileReader(path);
      
        // 第二种方式：直接返回一个流（InputStream）
        InputStream reader = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("com/bjpowernode/java/bean/example");

        // 创建Map集合对象
        Properties pro = new Properties();
        pro.load(reader);
        reader.close();
        // 通过key获取value
        String className = pro.getProperty("className");

        // 创建对象
        Class c = Class.forName(className);
        Object obj= c.newInstance();
        System.out.println(obj); // Wed Aug 03 17:00:36 CST 2022

    }
}

** 第三种方式：利用资源绑定器（常用）**

（1）前两种方式都需要创建一个流，而是用资源绑定器就不需要了！

（2）java.util包下提供了一个资源绑定器，便于获取属性配置文件中的内容。
（3）使用这种方式的时候，属性配置文件xxx.properties必须放到类路径下。
资源绑定器，只能绑定xxx.properties文件。并且这个文件必须在类路径下。文件扩展名也必须是properties
（4）并且在写路径的时候，路径后面的扩展名.properties不能写。

ResourceBundle boudle = ResourceBundle.getBundle("classinfo");
String className = boudle.getString("className");

package com.bjpowernode.java.reflect;

import java.util.ResourceBundle;

public class ResourceBundleTest {
    public static void main(String[] args) throws Exception {
        // 例如：classinfo.properties（className=java.util.Date）
        ResourceBundle boudle = ResourceBundle.getBundle("classinfo");
        // 通过key获取value
        String className = boudle.getString("className");
        //System.out.println(className); // java.util.Date
        // 实例化对象
        Class c = Class.forName(className);
        Object obj = c.newInstance();
        System.out.println(obj); // Wed Aug 03 19:31:20 CST 2022

    }
}

6. 扩展：类加载器概述

关于JDK中自带的类加载器：（不需要掌握）
（1）什么是类加载器？
专门负责加载类的命令/工具；ClassLoader
（2）JDK中自带了3个类加载器
启动类加载器：rt.jar
扩展类加载器：ext/*.jar
应用类加载器：classpath
（3）假设有这样一段代码：String s = "abc";
代码在开始执行之前，会将所需要类全部加载到JVM当中。通过类加载器加载，看到以上代码类加载器会找String.class文件，找到就加载，那么是怎么进行加载的呢？

   首先通过“启动类加载器”加载
        注意：启动类加载器专门加载：C:\Program Files\Java\jdk1.8.0_101\jre\lib\rt.jar
        rt.jar中都是JDK最核心的类库。
   如果通过“启动类加载器”加载不到的时候，然后会通过"扩展类加载器"加载
        注意：扩展类加载器专门加载：C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\*.jar
   如果“扩展类加载器”没有加载到，那么会通过“应用类加载器”加载
         注意：应用类加载器专门加载：classpath中的类。

（4）java中为了保证类加载的安全，使用了双亲委派机制。
优先从启动类加载器中加载，这个称为“父”，“父”无法加载到，再从扩展类加载器中加载，这个称为“母”。

    双亲委派。如果都加载不到，才会考虑从应用类加载器中加载。直到加载到为止。

小总结

1、回顾反射机制

（1）什么是反射机制？反射机制有什么用？
反射机制：可以操作字节码文件
作用：可以让程序更加灵活

（2）反射机制相关的类在哪个包下？
java.lang.reflect.*;

（3）反射机制相关的主要的类？
java.lang.Class
java.lang.reflect.Method;
java.lang.reflect.Constructor;
java.lang.reflect.Field;

（4）在java中获取Class的三种方式？
第一种：
Class c = Class.forName("完整类名");
第二种：
Class c = 对象.getClass();
第三种：
Class c = int.class;

（5）获取了Class之后，可以调用无参数构造方法来实例化对象

//c代表的就是日期Date类型
Class c = Class.forName("java.util.Date");
//实例化一个Date日期类型的对象
Object obj = c.newInstance();

    一定要注意：

        newInstance()底层调用的是该类型的无参数构造方法。
         如果没有这个无参数构造方法会出现"实例化"异常。

（6）如果你只想让一个类的“静态代码块”执行的话，你可以怎么做？
Class.forName("该类的类名");这样类就加载，类加载的时候，静态代码块执行！
（7）关于路径问题？

String path = Thread.currentThread().getContextClassLoader()
    .getResource("写相对路径，但是这个相对路径从src出发开始找").getPath();    

String path = Thread.currentThread().getContextClassLoader()
    .getResource("abc").getPath();    //必须保证src下有abc文件。

String path = Thread.currentThread().getContextClassLoader()
    .getResource("a/db").getPath();    //必须保证src下有a目录，a目录下有db文件。
        

    这种方式是为了获取一个文件的绝对路径。（通用方式，不会受到环境移植的影响）

但是该文件要求放在类路径下，换句话说：也就是放到src下面。src下是类的根路径。

// 直接以流的形式返回：
InputStream in = Thread.currentThread().getContextClassLoader()
     .getResourceAsStream("com/bjpowernode/test.properties");

（8）IO流 + Properties集合，怎么快速绑定属性资源文件？

// 第一：第一这个文件必须在类路径(src)下
// 第二：这个文件必须是以.properties结尾，但是写的时候不能带上.properties。
ResourceBundle bundle = ResourceBundle.getBundle("com/bjpowernode/test");
String value = bundle.getString(key);

结束语

今天的分享就到这里啦！快快通过下方链接注册加入刷题大军吧！各种大厂面试真题在等你哦！
💬刷题神器，从基础到大厂面试题👉点击跳转刷题网站进行注册学习