Java基础进阶反射

Dear 丶 2023-10-08 16:54 55阅读 0赞

#### 文章目录 ####

*   *  反射机制有什么用？
     *  反射机制的相关类在哪个包下？
     *  反射机制相关的重要的类有哪些？
     *  获取Class的三种方式：
     *   *  示例代码01：
         *  运行结果：
     *  获取Class，能干什么？
     *   *  示例代码02：
         *  运行结果：
     *  反射机制的灵活性。
     *   *  示例代码02：
         *  运行结果：
     *  Class.forName()发生了什么？
     *   *  示例代码03：
         *  运行结果：
     *  怎么获取一个文件的绝对路径。
     *   *  示例代码04：
         *  运行结果：
     *  文件路径直接以流的形式返回：
     *   *  示例代码05：
         *  运行结果：
     *  通过反射获取属性值Field（以Student类举例）
     *   *  示例代码06：
         *  运行结果：
     *  通过反射机制，反编译一个类的属性Field
     *   *  示例代码07：
         *  运行结果：
     *  怎么通过反射机制访问一个java对象的属性？
     *   *  示例代码08：
         *  运行结果：
     *  通过反射获取Method
     *   *  示例代码09：
         *  运行结果：
     *  通过反射反编译对象方法Method
     *   *  示例代码10：
         *  运行结果：
     *  重点：通过反射机制怎么调用一个对象的方法？
     *   *  示例代码11：
         *  运行结果：
     *  反编译一个类的Constructor构造方法。
     *   *  示例代码12：
         *  运行结果：
     *  通过反射机制调用构造方法实例化java对象。
     *   *  示例代码13：
         *  运行结果：
     *  通过反射机制怎么获取这个类的父类，和它自己已经实现的接口
     *   *  示例代码14：
         *  运行结果：
     *  资源绑定器
     *   *  示例代码15：
         *  运行结果：

### 反射机制有什么用？ ###

通过java语言中的反射机制可以操作字节码文件。  
优点类似于黑客。（可以读和修改字节码文件。）  
通过反射机制可以操作代码片段。（class文件。）  
![在这里插入图片描述][dc2d2991b774484d93a0586ac8c4b910.png_pic_center]

### 反射机制的相关类在哪个包下？ ###

java.lang.reflect.*;

### 反射机制相关的重要的类有哪些？ ###

*  java.lang.Class：代表整个字节码，代表一个类型，代表整个类。
 *  java.lang.reflect.Method：代表字节码中的方法字节码。代表类中的方法。
 *  java.lang.reflect.Constructor：代表字节码中的构造方法字节码。代表类中的构造方法
 *  java.lang.reflect.Field：代表字节码中的属性字节码。代表类中的成员变量（静态变量+实例变量）。

### 获取Class的三种方式： ###

java中获取Class的三种方式？要操作一个类的字节码，需要首先获取到这个类的字节码，怎么获取java.lang.Class实例  
第一种：

Class c = Class.forName("完整类名");

第二种：

Class c = 对象.getClass();

第三种：

Class c = int.class;
    Class c = String.class;

#### 示例代码01： ####

public class ReflectTest01 {
        
        public static void main(String[] args) throws ClassNotFoundException {
        
    
            /*
            Class.forName()
                1、静态方法
                2、方法的参数是一个字符串。
                3、字符串需要的是一个完整类名。
                4、完整类名必须带有包名。java.lang包也不能省略。
             */
            Class c1 = Class.forName("java.lang.String");// c1代表String.class文件，或者说c1代表String类型。
            Class c2 = Class.forName("java.util.Date");// c2代表Date类型
            Class c3 = Class.forName("java.lang.Integer");// c3代表Integer类型
            Class c4 = Class.forName("java.lang.System");// c4代表System类型
    
            // java中任何一个对象都有一个方法：getClass()
            String s = "abc";
            Class x = s.getClass();// x代表String.class字节码文件，x代表String类型。
            System.out.println(c1 == x);// true（==判断的是对象的内存地址。）
    
            Date date = new Date();
            Class d = date.getClass();
            System.out.println(c2 == d);// true (c2和y两个变量中保存的内存地址都是一样的，都指向方法区中的字节码文件。)
    
            // 第三种方式，java语言中任何一种类型，包括基本数据类型，它都有.class属性。
            Class z = String.class;//z代表String类型
            Class k = Date.class;//k代表Date类型
            Class f = int.class;//f代表int类型
            Class e = double.class;//e代表double类型
    
            System.out.println(x == z);// true
        }
    }

#### 运行结果： ####

![在这里插入图片描述][dff983dfbc594ee599c02284ed57510a.png]

### 获取Class，能干什么？ ###

*  通过Class的newInstance（）方法来实例化对象
 *  注意：newInstance（）方法内部实际上调用了无参构造方法，必须保证无参构造存在。

#### 示例代码02： ####

public class ReflectTest {
        
        public static void main(String[] args) {
        
    
            //不使用反射创建对象
            User user = new User();
            System.out.println(user);
            Class c;
    
            {
        
                try {
        
                    //使用反射创建对象，通过反射机制，获取Class，通过Class来实例化对象
                    c = Class.forName("com.newstudy.javase.bean.User");//c代表User类型
                    //newInstance()这个方法会调用User这个类的无参构造方法，完成对象的创建！
                    //重点是：newInstance（）调用的是无参构造方法，必须保证无参构造是存在的
                    Object o = c.newInstance();
                    System.out.println(o);
                } catch (ClassNotFoundException e) {
        
                    e.printStackTrace();
                } catch (InstantiationException e) {
        
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }
    class User {
        
    
        public User(){
        
            System.out.println("无参构造方法执行！");
        }
        /*public User(){
    
        }*/
    }

#### 运行结果： ####

![在这里插入图片描述][5380767f5ce64a2a94a28102b096cb64.png]

### 反射机制的灵活性。 ###

java代码写一遍，再不改变java源代码的基础之上，可以做到不同对象的实例化。  
非常之灵活。（符合OCP开闭原则：对扩展开放，对修改关闭。）

#### 示例代码02： ####

public class ReflectTest03 {
        
        public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {
        
    
            // 这种方式代码就写死了。只能创建一个User类型的对象
            //User user = new User();
    
            // 以下代码是灵活的，代码不需要改动，可以修改配置文件，配置文件修改之后，可以创建出不同的实例对象。
            // 通过IO流读取classinfo.properties文件
            FileReader reader = new FileReader("reflect/src/classinfo.properties");
    
            //在创建properties对象
            // 创建属性类对象Map
            Properties pro = new Properties();
    
            //把文件通过流方式加载到properties集合中
            pro.load(reader);
    
            // 关闭流
            reader.close();
    
            //通过key获取value
            String classname = pro.getProperty("classname");
            System.out.println(classname);
    
            //通过反射创建对象，实例化对象
            Class c = Class.forName(classname);
            Object o = c.newInstance();
            System.out.println(o);
    
    
        }
    }

#### 运行结果： ####

![在这里插入图片描述][aaa7ec2c00f94d268b8d4e02703ad802.png]

### Class.forName()发生了什么？ ###

记住，重点：  
如果你只是希望一个类的静态代码块执行，其它代码一律不执行，  
你可以使用：  
Class.forName(“完整类名”);  
这个方法的执行会导致类加载，类加载时，静态代码块执行。

#### 示例代码03： ####

public class ReflectTest04 {
        
        public static void main(String[] args) {
        
    
            try {
        
                // Class.forName()这个方法的执行会导致：类加载。
                Class c = Class.forName("com.newstudy.javase.reflect.MyClass");
            } catch (ClassNotFoundException e) {
        
                e.printStackTrace();
            }
        }
    }
    public class MyClass {
        
    
        static{
        
    
            // 静态代码块在类加载时执行，并且只执行一次。
            System.out.println("MyClass的静态代码块执行了！");
        }
    }

![在这里插入图片描述][16de93daebd24ef28fa3491970f47d7c.png]

#### 运行结果： ####

![在这里插入图片描述][8dcb676374674eb1b520311f35dd240c.png]

### 怎么获取一个文件的绝对路径。 ###

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

#### 示例代码04： ####

public class AboutPathTest {
        
        public static void main(String[] args) {
        
    
            // 这种方式的路径缺点是：移植性差，在IDEA中默认的当前路径是project的根。
            // 这个代码假设离开了IDEA，换到了其它位置，可能当前路径就不是project的根了，这时这个路径就无效了。
            //FileReader reader = new FileReader("chapter25/classinfo2.properties");
    
            // 接下来说一种比较通用的一种路径。即使代码换位置了，这样编写仍然是通用的。
            // 注意：使用以下通用方式的前提是：这个文件必须在类路径下。
            // 什么类路径下？方式在src下的都是类路径下。【记住它】
            // src是类的根路径。
            /*
            解释：
                Thread.currentThread() 当前线程对象
                getContextClassLoader() 是线程对象的方法，可以获取到当前线程的类加载器对象。
                getResource() 【获取资源】这是类加载器对象的方法，当前线程的类加载器默认从类的根路径下加载资源。
             */
            // 这种方式获取文件绝对路径是通用的。
            String path1 = Thread.currentThread().getContextClassLoader().getResource("classinfo2.properties").getPath();
            // 采用以上的代码可以拿到一个文件的绝对路径。
            // /C:/Users/Administrator/IdeaProjects/javase/out/production/chapter25/classinfo2.properties
            System.out.println(path1);
    
            // 获取db.properties文件的绝对路径（从类的根路径下作为起点开始）
            String path2 = Thread.currentThread().getContextClassLoader().getResource("com/newstudy/javase/bean/db.properties").getPath();
            System.out.println(path2);
        }
    }

![在这里插入图片描述][45338edc63664f39bde6f04f755c9ade.png]

![在这里插入图片描述][c2286e6edd5d459e8934829127eedb84.png]

#### 运行结果： ####

![在这里插入图片描述][cbd29be3b2b24ddeb8759548493f96a9.png]

### 文件路径直接以流的形式返回： ###

> InputStream in = Thread.currentThread().getContextClassLoader()  
> .getResourceAsStream(“com/bjpowernode/test.properties”);

#### 示例代码05： ####

public class IoPropertiesTest {
        
    
        public static void main(String[] args) throws IOException {
        
    
            // 获取一个文件的绝对路径了！！！！！
            /*String path = Thread.currentThread().getContextClassLoader()
                    .getResource("classinfo2.properties").getPath();
            FileReader reader = new FileReader(path);*/
    
            //直接以流的方式返回
            InputStream reader = Thread.currentThread().getContextClassLoader()
                    .getResourceAsStream("classinfo2.properties");
            Properties pro = new Properties();
            pro.load(reader);
            reader.close();
            //通过key获取value
            String classname = pro.getProperty("classname");
            System.out.println(classname);
    
        }
    }

#### 运行结果： ####

![在这里插入图片描述][d22f0290df3a42a5ae633233af4b7ac9.png]

### 通过反射获取属性值Field（以Student类举例） ###

#### 示例代码06： ####

public class ReflectTest05 {
        
        public static void main(String[] args) throws ClassNotFoundException {
        
    
            // 获取整个类
            Class student = Class.forName("com.newstudy.javase.bean.Student");
            //获取完整类名
            String studentName = student.getName();
            System.out.println("完整类名：" + studentName);
            //获取简单类名
            String studentSimpleName = student.getSimpleName();
            System.out.println("简单类名：" + studentSimpleName);
    
            //获取类属性
            /*Field[] fields = student.getFields();
            System.out.println(fields.length); // 测试数组中只有1个元素
            Field field = fields[0];
            System.out.println(field.getName());*/
    
            //获取所有属性字段
            Field[] fs = student.getDeclaredFields();
            for(Field fieldo : fs) {
        
                //获取字段修饰符列表
                int i = fieldo.getModifiers();// 返回的修饰符是一个数字，每个数字是修饰符的代号！！！
                // 可以将这个“代号”数字转换成“字符串”吗？
                String s = Modifier.toString(i);
                System.out.println(s);
                //获取字段类型名字
                /*Class type = fieldo.getType();
                System.out.println(type.getName());*/
                //获取字段类型简单名字
                Class type1 = fieldo.getType();
                System.out.println(type1.getSimpleName());
                //获取字段名字
                System.out.println(fieldo.getName());
            }
        }
    }
    public class Student {
        
        public int no;
        private String name;
        protected int age;
        boolean sex;
    }

#### 运行结果： ####

![在这里插入图片描述][290685dd5a264ba886ccdf9eedced36a.png]

### 通过反射机制，反编译一个类的属性Field ###

#### 示例代码07： ####

public class ReflectTest06 {
        
        public static void main(String[] args) throws ClassNotFoundException {
        
    
            //获取整个类
            Class student = Class.forName("java.lang.Thread");
    
            //创建字符串拼接对象// 创建这个是为了拼接字符串。
            StringBuilder sb = new StringBuilder();
            sb.append(Modifier.toString(student.getModifiers()) + " class " + student.getSimpleName() + "{\n");
            Field[] fields = student.getDeclaredFields();
            for(Field field : fields) {
        
                sb.append("\t");
                sb.append(Modifier.toString(field.getModifiers()));
                sb.append(" ");
                sb.append(field.getType().getSimpleName());
                sb.append(" ");
                sb.append(field.getName());
                sb.append(";\n");
            }
            sb.append("}");
            System.out.println(sb);
        }
    }

#### 运行结果： ####

![在这里插入图片描述][cda54bf24a04433b9c06c28672e2a156.png]

### 怎么通过反射机制访问一个java对象的属性？ ###

给属性赋值set  
获取属性的值get

#### 示例代码08： ####

public class ReflectTest07 {
        
    
        public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        
    
            //不使用反射修改获取对象值
            Student student1 = new Student();
            // 给属性赋值
            student1.no = 123456789;//三要素：给s对象的no属性赋值1111
                                    //要素1：对象s
                                    //要素2：no属性
                                    //要素3：1111
            // 读属性值
            // 两个要素：获取s对象的no属性的值。
            System.out.println(student1.no);
    
            //获取Student对象// 使用反射机制，怎么去访问一个对象的属性。（set get）
            Class student = Class.forName("com.newstudy.javase.bean.Student");
    
            //实例化对象
            Object o = student.newInstance();
    
            //获取其中一个属性值// 获取no属性（根据属性的名称来获取Field）
            Field nofield = student.getDeclaredField("no");
    
            //给属性设置值
            // 给obj对象(Student对象)的no属性赋值
            /*
            虽然使用了反射机制，但是三要素还是缺一不可：
                要素1：obj对象
                要素2：no属性
                要素3：2222值
            注意：反射机制让代码复杂了，但是为了一个“灵活”，这也是值得的。
             */
            nofield.set(o,382155);// 给obj对象的no属性赋值382155
    
            //获取修改后的属性值
            // 读取属性的值
            // 两个要素：获取obj对象的no属性的值。
            System.out.println(nofield.get(o));
    
            //可以访问私有属性吗
            Field namefield = student.getDeclaredField("name");
    
            //打破封装
            namefield.setAccessible(true);
            namefield.set(o,"wangyilin");
            System.out.println(namefield.get(o));//此处如果不打破分装，会报权限访问异常
    
        }
    }
    public class Student {
        
        public int no;
        private String name;
        protected int age;
        boolean sex;
    }

#### 运行结果： ####

![在这里插入图片描述][5e5f8fb104c147a7ac59002d3a591dd3.png]

### 通过反射获取Method ###

#### 示例代码09： ####

public class ReflectTest08 {
        
        public static void main(String[] args) throws ClassNotFoundException {
        
    
            //获取UserService类型
            Class userService = Class.forName("com.newstudy.javase.bean.UserService");
    
            //获取方法名字// 获取所有的Method（包括私有的！）
            Method[] methods = userService.getDeclaredMethods();
    
            for(Method method :methods){
        
                //获取方法的修饰符
                System.out.println(Modifier.toString(method.getModifiers()));
                //获取方法的返回类型
                System.out.println(method.getReturnType().getSimpleName());
                //获取方法的名字
                System.out.println(method.getName());
                //获取方法的参数列表（方法可以有多个参数）
                Class[] parameterTypes = method.getParameterTypes();
                for(Class parameterType : parameterTypes){
        
                    System.out.println(parameterType.getSimpleName());
                }
    
            }
    
        }
    }

#### 运行结果： ####

![在这里插入图片描述][4c1cd633eb284e40b63900b2a366f277.png]

### 通过反射反编译对象方法Method ###

#### 示例代码10： ####

public class ReflectTest09 {
        
        public static void main(String[] args) throws ClassNotFoundException {
        
    
            StringBuilder s = new StringBuilder();
            //Class userServiceClass = Class.forName("com.bjpowernode.java.service.UserService");
            Class userServiceClass = Class.forName("java.lang.String");
            s.append(Modifier.toString(userServiceClass.getModifiers()) + " class "+userServiceClass.getSimpleName()+" {\n");
    
            Method[] methods = userServiceClass.getDeclaredMethods();
            for(Method method : methods){
        
                //public boolean login(String name,String password){}
                s.append("\t");
                s.append(Modifier.toString(method.getModifiers()));
                s.append(" ");
                s.append(method.getReturnType().getSimpleName());
                s.append(" ");
                s.append(method.getName());
                s.append("(");
                // 参数列表
                Class[] parameterTypes = method.getParameterTypes();
                for(Class parameterType : parameterTypes){
        
                    s.append(parameterType.getSimpleName());
                    s.append(",");
                }
                // 删除指定下标位置上的字符
                s.deleteCharAt(s.length() - 1);
                s.append("){}\n");
            }
    
            s.append("}");
            System.out.println(s);
        }
    }

#### 运行结果： ####

![在这里插入图片描述][1b6dd34a93904dccb399315362e8af9a.png]

### 重点：通过反射机制怎么调用一个对象的方法？ ###

反射机制，让代码很具有通用性，可变化的内容都是写到配置文件当中，  
将来修改配置文件之后，创建的对象不一样了，调用的方法也不同了，  
但是java代码不需要做任何改动。这就是反射机制的魅力。

#### 示例代码11： ####

public class ReflectTest10 {
        
        public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        
    
            // 不使用反射机制，怎么调用方法
            // 创建对象
            UserService userService1 = new UserService();
            // 调用方法
            /*
            要素分析：
                要素1：对象userService
                要素2：login方法名
                要素3：实参列表
                要素4：返回值
             */
            boolean loginSuccess = userService1.login("admin","123");
            //System.out.println(loginSuccess);
            System.out.println(loginSuccess ? "登录成功" : "登录失败");
            //获取类型
            Class userService = Class.forName("com.newstudy.javase.bean.UserService");
    
            //实例化对象
            Object o = userService.newInstance();
    
            //获取方法
            Method login = userService.getMethod("login", String.class, String.class);
            //Method login = userService.getMethod("login", int.class);
            // 调用方法
            // 调用方法有几个要素？ 也需要4要素。
            // 反射机制中最最最最最重要的一个方法，必须记住。
            /*
            四要素：
            loginMethod方法
            obj对象
            "admin","123" 实参
            retValue 返回值
             */
    
            //调用方法
            Object reValue = login.invoke(o, "admin", "123");
            System.out.println(reValue);
        }
    }
    public class UserService {
        
    
        public boolean login(String username,String password){
        
            if("123".equals(username) && "admian".equals(password)){
        
                return true;
            }
            return false;
        }
    
        public  void loginout(){
        
            System.out.println("退出系统，欢迎下次光临！");
        }
    
        public void login(int age){
        
    
        }
    }

#### 运行结果： ####

![在这里插入图片描述][aa555aae3bd545de962d01657c90b82d.png]

### 反编译一个类的Constructor构造方法。 ###

#### 示例代码12： ####

public class ReflectTest11 {
        
        public static void main(String[] args) throws Exception{
        
            StringBuilder s = new StringBuilder();
            Class vipClass = Class.forName("java.lang.String");
            s.append(Modifier.toString(vipClass.getModifiers()));
            s.append(" class ");
            s.append(vipClass.getSimpleName());
            s.append("{\n");
    
            // 拼接构造方法
            Constructor[] constructors = vipClass.getDeclaredConstructors();
            for(Constructor constructor : constructors){
        
                //public Vip(int no, String name, String birth, boolean sex) {
        
                s.append("\t");
                s.append(Modifier.toString(constructor.getModifiers()));
                s.append(" ");
                s.append(vipClass.getSimpleName());
                s.append("(");
                // 拼接参数
                Class[] parameterTypes = constructor.getParameterTypes();
                for(Class parameterType : parameterTypes){
        
                    s.append(parameterType.getSimpleName());
                    s.append(",");
                }
                // 删除最后下标位置上的字符
                if(parameterTypes.length > 0){
        
                    s.deleteCharAt(s.length() - 1);
                }
                s.append("){}\n");
            }
    
            s.append("}");
            System.out.println(s);
        }
    }

#### 运行结果： ####

![在这里插入图片描述][907a68be51db4f73a20120849167fb4d.png]

### 通过反射机制调用构造方法实例化java对象。 ###

#### 示例代码13： ####

public class ReflectTest12 {
        
        public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        
    
            //不使用反射通过构造器创建对象
            Vip vip1 = new Vip();
            Vip vip = new Vip(110,"zhagnsan","1997-09-19",true);
    
            //获取类型
            Class Vip2 = Class.forName("com.newstudy.javase.bean.Vip");
            //通过无参构造方法反射实例化Vip对象
            Object o = Vip2.newInstance();
            System.out.println(o);
    
            //通过反射调用构造器创建方法
            //调用有参构造方法
            //先获取有参构造方法
            Constructor constructor = Vip2.getDeclaredConstructor(int.class, String.class, String.class, boolean.class);
            Object o1 = constructor.newInstance(100,"jiameihong","2022-19-9",false);
            System.out.println(o1);
    
        }
    }
    public class Vip {
        
        private int no;
        private String name;
        private String birth;
        boolean sex;
    
        public Vip() {
        
        }
    
        public Vip(int no, String name, String birth, boolean sex) {
        
            this.no = no;
            this.name = name;
            this.birth = birth;
            this.sex = sex;
        }
    
        public int getNo() {
        
            return no;
        }
    
        public void setNo(int no) {
        
            this.no = no;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public String getBirth() {
        
            return birth;
        }
    
        public void setBirth(String birth) {
        
            this.birth = birth;
        }
    
        public boolean isSex() {
        
            return sex;
        }
    
        public void setSex(boolean sex) {
        
            this.sex = sex;
        }
    
        @Override
        public String toString() {
        
            return "Vip{" +
                    "no=" + no +
                    ", name='" + name + '\'' +
                    ", birth='" + birth + '\'' +
                    ", sex=" + sex +
                    '}';
        }
    }

#### 运行结果： ####

![在这里插入图片描述][002340c0aee446aebb393d6ca6c2e065.png]

### 通过反射机制怎么获取这个类的父类，和它自己已经实现的接口 ###

#### 示例代码14： ####

public class RefectTest13 {
        
        public static void main(String[] args) throws ClassNotFoundException {
        
    
            //获取类型
            Class stringclass = Class.forName("java.lang.String");
    
            //获取类型的父类
            Class superclass = stringclass.getSuperclass();
            System.out.println(superclass.getName());
            // 获取String类实现的所有接口（一个类可以实现多个接口。）
            Class[] interfaces = stringclass.getInterfaces();
            for(Class in : interfaces){
        
                //输出实现接口的名字
                System.out.println(in.getName());
            }
    
        }
    }

#### 运行结果： ####

![在这里插入图片描述][362b14d5c42f4d2a9f41ec2fb795bb48.png]

### 资源绑定器 ###

java.util包下提供了一个资源绑定器，便于获取属性配置文件中的内容。  
使用以下这种方式的时候，属性配置文件xxx.properties必须放到类路径下。

#### 示例代码15： ####

public class ResourceBundleTest4 {
        
        public static void main(String[] args) {
        
    
            // 资源绑定器，只能绑定xxx.properties文件。并且这个文件必须在类路径下。文件扩展名也必须是properties
            // 并且在写路径的时候，路径后面的扩展名不能写。
            ResourceBundle bundle = ResourceBundle.getBundle("classinfo2");
    
            ResourceBundle bundle1 = ResourceBundle.getBundle("com/newstudy/javase/bean/db");
            //通过key获取value
            String classname = bundle.getString("classname");
            System.out.println(classname);
            String classname1 = bundle1.getString("classname");
            System.out.println(classname1);
        }
    }

![在这里插入图片描述][df74d8bb45ff4fa2b1e94e0a9bedad28.png]

![在这里插入图片描述][6f406a29d1e54bab8c3a20653b91cbdb.png]

#### 运行结果： ####

![在这里插入图片描述][1d2fc59bde674a968fdefbfe33930b08.png]

[dc2d2991b774484d93a0586ac8c4b910.png_pic_center]: https://img-blog.csdnimg.cn/dc2d2991b774484d93a0586ac8c4b910.png#pic_center
[dff983dfbc594ee599c02284ed57510a.png]: https://img-blog.csdnimg.cn/dff983dfbc594ee599c02284ed57510a.png
[5380767f5ce64a2a94a28102b096cb64.png]: https://img-blog.csdnimg.cn/5380767f5ce64a2a94a28102b096cb64.png
[aaa7ec2c00f94d268b8d4e02703ad802.png]: https://img-blog.csdnimg.cn/aaa7ec2c00f94d268b8d4e02703ad802.png
[16de93daebd24ef28fa3491970f47d7c.png]: https://img-blog.csdnimg.cn/16de93daebd24ef28fa3491970f47d7c.png
[8dcb676374674eb1b520311f35dd240c.png]: https://img-blog.csdnimg.cn/8dcb676374674eb1b520311f35dd240c.png
[45338edc63664f39bde6f04f755c9ade.png]: https://img-blog.csdnimg.cn/45338edc63664f39bde6f04f755c9ade.png
[c2286e6edd5d459e8934829127eedb84.png]: https://img-blog.csdnimg.cn/c2286e6edd5d459e8934829127eedb84.png
[cbd29be3b2b24ddeb8759548493f96a9.png]: https://img-blog.csdnimg.cn/cbd29be3b2b24ddeb8759548493f96a9.png
[d22f0290df3a42a5ae633233af4b7ac9.png]: https://img-blog.csdnimg.cn/d22f0290df3a42a5ae633233af4b7ac9.png
[290685dd5a264ba886ccdf9eedced36a.png]: https://img-blog.csdnimg.cn/290685dd5a264ba886ccdf9eedced36a.png
[cda54bf24a04433b9c06c28672e2a156.png]: https://img-blog.csdnimg.cn/cda54bf24a04433b9c06c28672e2a156.png
[5e5f8fb104c147a7ac59002d3a591dd3.png]: https://img-blog.csdnimg.cn/5e5f8fb104c147a7ac59002d3a591dd3.png
[4c1cd633eb284e40b63900b2a366f277.png]: https://img-blog.csdnimg.cn/4c1cd633eb284e40b63900b2a366f277.png
[1b6dd34a93904dccb399315362e8af9a.png]: https://img-blog.csdnimg.cn/1b6dd34a93904dccb399315362e8af9a.png
[aa555aae3bd545de962d01657c90b82d.png]: https://img-blog.csdnimg.cn/aa555aae3bd545de962d01657c90b82d.png
[907a68be51db4f73a20120849167fb4d.png]: https://img-blog.csdnimg.cn/907a68be51db4f73a20120849167fb4d.png
[002340c0aee446aebb393d6ca6c2e065.png]: https://img-blog.csdnimg.cn/002340c0aee446aebb393d6ca6c2e065.png
[362b14d5c42f4d2a9f41ec2fb795bb48.png]: https://img-blog.csdnimg.cn/362b14d5c42f4d2a9f41ec2fb795bb48.png
[df74d8bb45ff4fa2b1e94e0a9bedad28.png]: https://img-blog.csdnimg.cn/df74d8bb45ff4fa2b1e94e0a9bedad28.png
[6f406a29d1e54bab8c3a20653b91cbdb.png]: https://img-blog.csdnimg.cn/6f406a29d1e54bab8c3a20653b91cbdb.png
[1d2fc59bde674a968fdefbfe33930b08.png]: https://img-blog.csdnimg.cn/1d2fc59bde674a968fdefbfe33930b08.png