--- theme: condensed-night-purple highlight: an-old-hope --- ### 1.反射 #### 1.1 反射的概述我们首先要知道什么是反射： `反射就是指在运行状态中，对于任意一个类，都能够知道并调用这个类的所有属性和方法。这种动态获取对象信息和动态调用对象方法的功能叫做Java反射。` 可能上面的解释各位理解不了，那么我就通俗理解一下就是： (1).`利用反射创建的对象可以无视修饰符而调用里面的类里面的内容;` (2).`可以跟配置文件结合使用，把要创建的对象信息和方法写入到配置文件里面;` #### 1.2 学习反射到底是学习什么反射都是从class字节码文件里面获得的内容 (1).`如何获取class字节码文件对象` (2).`利用反射如何获取构造方法(创建对象)` (3).`利用反射如何获取成员变量(赋值，获取值)` (4).`利用反射如何获取成员方法(运行)` ##### 我们本次的测试类是User类，它的源码如下： ``` package com.example.main; public class User{ private String name; private String passWord; public User(){} private User(String name){ this.name = name; } public User(String name, String passWord) { this.name = name; this.passWord = passWord; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getPassWord() { return passWord; } public void setPassWord(String passWord) { this.passWord = passWord; } //重写 @Override public String toString() { return "User{" + "name='" + name + ''' + ", passWord='" + passWord + ''' + '}'; } } ``` #### 1.3 获取class字节码文件对象的三种方式 ``` package com.example.main; public class Main { //注意：千万别忘了抛出异常 public static void main(String[] args) throws ClassNotFoundException { //1.通过调用Class里面静态方法forName() //注意里面的参数应输入为“全类名”，即全类名=包名+类名 //里面的clazz1就是Student这个类的字节码文件对象 Class clazz1 = Class.forName("com.example.main.User"); //这里使用了泛型是为了增加灵活性和安全性，里面的?可以是任意类型。 //这里源代码的获取阶段就是————先将User这个类加载到内存中之后，再获取User.class产生的字节码文件对象。 //2.通过class属性获取 Class clazz2 = User.class; //熟悉Java栈堆的应该明白，虽然这里的两个字节码对象在栈里面地址不同，但是由于class文件在硬盘中是唯一的，因此加载到内存里面产生的对象也是唯一的。 System.out.println(clazz2 == clazz1);//true //3.可以直接通过User类来获取字节码文件对象 User user = new User(); Class clazz3 = user.getClass(); System.out.println(clazz1 == clazz3);//true System.out.println(clazz2 == clazz3);//true } } ``` 说了半天大家可能还不知道什么是字节码文件和字节码文件对象，字节码文件就是`通过Java文件(我们写的Java代码)编译以后的class文件(这个文件在硬盘上是可以找到的)`;而字节码文件对象则是`class文件(即字节码文件)在加载到内存中之后，JVM会自动创建好它的对象，而且这个对象里面至少包含了构造函数、成员变量和成员方法。` 我们获取的是什么？字节码文件对象，它在内存(不是硬盘)中是唯一的。 #### 1.4 获取构造方法 ``` package com.example.main; import java.lang.reflect.Constructor; public class Main { //注意：千万别忘了抛出异常 public static void main(String[] args) throws ClassNotFoundException,NoSuchMethodException { //第一步肯定还是要先获得字节码文件对象 Class clazz = Class.forName("com.example.main.User"); //1.获取所有的(public)构造方法,这里的数据类型必须用Constructor。 //这里的Constructor里面的泛型也是为了增强安全性和灵活性 Constructor[] constructors1 = clazz.getConstructors(); for (Constructor c: constructors1) { System.out.println(c); } System.out.println("-----------------------------------"); //2.获取所有的构造方法(包括private方法)。 Constructor[] constructors2 = clazz.getDeclaredConstructors(); for (Constructor c: constructors2) { System.out.println(c); } System.out.println("------------------------------------"); //3.获取指定的空参构造 Constructor constructor3 = clazz.getConstructor(); System.out.println(constructor3); //观察控制台打印的数据，你会发现什么？ Constructor constructor4 = clazz.getDeclaredConstructor(String.class,String.class); System.out.println(constructor4); Constructor constructor5 = clazz.getConstructor(); //之所以不相等是因为每次获得构造方法对象时，都会新New一个对象。 System.out.println(constructor5 == constructor3);//false } } ``` 控制台打印的数据如下所示： ![1be0e4e71accbf5f479c6257175ebf9.png](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/2bb71249877e4d0cb6b20aed6b8b75da~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=1920&h=1029&s=125229&e=png&b=222326) #### 1.5 获取构造方法并创建对象涉及到的方法为：newInstance ``` package com.example.main; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; public class Main { //注意：千万别忘了抛出异常 public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException { //1.获取无参构造，并创建对象 //先获取字节码文件对象 Class clazz1 = Class.forName("com.example.main.User"); //获取空参构造方法 Constructor constructor = clazz1.getConstructor(); //利用空参构造方法创建对象 User user = (User) constructor.newInstance(); System.out.println(user.toString()); System.out.println("--------------------------------------"); //2.获取有参构造，并创建对象 //获得字节码文件对象 Class clazz2 = Class.forName("com.example.main.User"); //获取有参构造方法 Constructor constructor1 = clazz2.getDeclaredConstructor(String.class); //临时修改构造方法的访问权限，即暴力反射 constructor1.setAccessible(true); //直接创建对象 User user1 = (User) constructor1.newInstance("李金轩"); System.out.println(user1); } } ``` 控制台打印的结果如图所示： ![b7b516ad3e8c50667af2332be32b7df.png](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f90aac7fc7b7404e8b05c9993a1c7e64~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=1920&h=1029&s=95003&e=png&b=222326) #### 1.6 获取成员变量这个和获取构造方法的相关代码非常相似，直接看代码： ``` package com.example.main; import java.lang.reflect.Field; public class Main { //注意：千万别忘了抛出异常 public static void main(String[] args) throws ClassNotFoundException,NoSuchFieldException { //获取字节码文件对象 Class clazz1 = Class.forName("com.example.main.User"); //1.获取所有的public成员变量 Field[] fields = clazz1.getFields(); for (Field f: fields) { System.out.println(f);//User类我上面已经给了，由于都是私有变量，故这个打印结果肯定为空。 } //2.获取所有的成员变量(public+private) Field[] fields1 = clazz1.getDeclaredFields(); for (Field f:fields1) { System.out.println(f); } System.out.println("------------------------------"); /*3.获取指定的成员变量对象如果获取的变量为私有，或者该变量不存在，则会抛出NoSuchFieldException异常。 Field field = clazz1.getField("xiyan"); System.oyt.println(field); */ //4.获取单个成员变量(私有或公共都可以) Field field = clazz1.getDeclaredField("name"); System.out.println(field); } } ``` 控制台打印结果为： ![b46bec7f2b63d281dfe70d394a0910c.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/27a46ec044fb4f64b0e8f18e110e7882~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=1920&h=1029&s=138258&e=png&b=222326) #### 1.7 获取成员变量并修改值和获取值在这个例子中,我将User(String name)构造函数的修饰符由`private`改为了`public`,代码示例： ``` package com.example.main; import java.lang.reflect.Field; public class Main { //注意：千万别忘了抛出异常 public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException { //先实例化两个对象。 User user1 = new User("xiyan"); User user2 = new User("lijinxuan","21"); //目的：通过获取成员变量来获取值并修改值 //1.获取class对象 Class clazz1 = Class.forName("com.example.main.User"); //2.获取成员变量对象 Field field = clazz1.getDeclaredField("name"); //3.暴力反射 field.setAccessible(true); //4.设置name的值,此处第一个参数为要修改值的Java对象，第二个为要修改的值 field.set(user1,"Xiyan"); //5.获取指定对象的name的值 String name = (String) field.get(user1); //直接打印结果可以得到 System.out.println(name); System.out.println(user1); System.out.println(user2); } } ``` >对于上面的反射修改成员变量的值大家可能有点懵，正如我开始说的，反射是可以在运行状态中来动态调用类的属性或方法的，即先实例化对象之后，我们再用了反射来获取并修改Java对象的成员变量值。上面的运行结果如下： ![57e931776452de69d14a3f8465c84a1.png](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/6c9abea7610b423f99f09b9eb29a476e~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=1920&h=1029&s=143615&e=png&b=222326) #### 1.8 获取成员方法在这个例子中，我将User类改为了如下所示： ``` package com.example.main; public class User{ private String getYongJieName(String name){ if (!name.equals("jinxuan")){ return "情况不对，披坚执锐"; } else { return "金刚伏魔"; } } public String getLOLName(String name){ if (!name.equals("lijinxuan")){ return "德玛西亚"; } else { return "诺克萨斯"; } } protected void getXl(){ System.out.println("八嘎呀路"); } } ``` 接下来就是主方法执行代码，如下所示： ``` package com.example.main; import java.lang.reflect.Method; public class Main { //注意：千万别忘了抛出异常 public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException { //1.首先创建字节码文件对象 Class clazz = Class.forName("com.example.main.User"); //2.获取方法 //此处的getMethod()方法不仅获得了自己类内部的public方法，还可以获得父类中的public修饰的方法 Method[] methods = clazz.getMethods(); for (Method m : methods) { System.out.println(m); } System.out.println("================================="); //可以获得自己类内部的所有方法(私有+公共) Method[] methods1 = clazz.getDeclaredMethods(); for (Method m: methods1) { System.out.println(m); } System.out.println("================================="); //获得单个指定的方法(空参) Method method1 = clazz.getDeclaredMethod("getXl"); System.out.println(method1); //指定方法(有参) Method method2 = clazz.getMethod("getLOLName", String.class); System.out.println(method2); System.out.println("-----------------------------"); //获取指定的私有方法 Method method = clazz.getDeclaredMethod("getYongJieName", String.class); System.out.println(method); } } ``` 这是运行结果： ![6ea829256cf4fa748bd5ad1d6903d56.png](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/0f00b671513948548f5adf5615790e37~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=1920&h=1029&s=179827&e=png&b=222326) #### 1.9 获取成员方法并将其运行在这里我们需要使用`invoke`方法，即`Object invoke(Object object,Object...args)`，我们直接看代码吧： ``` package com.example.main; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public class Main { //注意：千万别忘了抛出异常 public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException { //1.先获取字节码文件对象 Class clazz = Class.forName("com.example.main.User"); //2.获取类的实例化对象 User user = new User(); //3.获取指定的成员方法 Method method1 = clazz.getDeclaredMethod("getYongJieName", String.class); Method method2 = clazz.getDeclaredMethod("getXl"); //由于getYongJieName()方法是private修饰，因此虽然获得了成员方法对象method1,但如果想访问成员方法则需要暴力反射。 method1.setAccessible(true); //4.运行 //invoke方法的第一个参数就是实例化对象，第二个是方法参数。 //如果方法有返回值则应该接收返回值。 //这里我需要说的就是如果method1方法本身就运行时抛出异常，那么Invoke会将其封装为InvocationTargetException异常抛出。 String s = (String) method1.invoke(user,"lijinxuan"); //默认返回的是Object类型 Object user1 = method1.invoke(user,"lijinxuan"); System.out.println(user1); System.out.println(s); //没有返回值则不用。 method2.invoke(user); } } ``` 运行结果： ![ba01982eac474eef3fa958cda968965.png](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/4a56340bbc5946b8aea67af63d00a64c~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=1920&h=1029&s=145461&e=png&b=222427)