一、反射机制的概念

• 指在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法，对于任意一个对象，都能调用它的任意一个方法。这种动态获取信息，及动态调用对象方法的功能叫java语言的反射机制。

• Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。

• Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。

二、反射的原理

（1）正常类的加载过程：

• 当执行new 方法，会触发JVM加载该对象的 .class 文件；
• JVM 从本地磁盘找到 .class 文件并加载到JVM内存中；
• .class 文件加载入内存后，JVM 会自动创建一个class 对象。（一个类只会产生一个class 对象）

（2）Java反射过程：
得到JVM内存中的class 对象，反向获取对象的各种信息。

三、反射的优缺点

1、优点

在运行时获得类的各种内容，进行反编译，对于Java这种先编译再运行的语言，能够让我们很方便的创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代码的链接，更加容易实现面向对象。

2、缺点

（1）反射会消耗一定的系统资源，因此，如果不需要动态地创建一个对象，那么就不需要用反射；
（2）反射调用方法时可以忽略权限检查，因此可能会破坏封装性而导致安全问题。

四、反射的用途

1. 可以进行反编译：.class–>.java
2. 通过反射机制访问java对象的属性，方法，构造方法等。
3. 我们在使用IDE，如Ecplise时，当输入一个对象或者类，并想调用他的属性和方法是，一按点号，编译器就会自动列出他的属性或者方法，这里就是用到反射。
4. 反射最重要的用途就是开发各种通用框架。比如很多框架（Spring）都是配置化的（比如通过XML文件配置Bean），为了保证框架的通用性，他们可能需要根据配置文件加载不同的类或者对象，调用不同的方法，这个时候就必须使用到反射了，运行时动态加载需要的加载的对象。
5. 加载数据库驱动的，用到的也是反射。
   eg：

Class.forName("com.mysql.jdbc.Driver"); // 动态加载mysql驱动

五、反射的常见使用

1、获得Class：主要有三种方法

• （1）getClass()。
• （2）任何数据类型（包括基本的数据类型）都有一个“静态”的class属性。
• （3）通过class类的静态方法：forName(String className)（最常用）。

注：三种方式中，常用第三种方式，
第一种对象都有了还要反射干什么，
第二种需要导入类包，依赖太强，不导包就抛编译错误。
一般都使用第三种，一个字符串可以传入也可以写在配置文件中等多种方法。

eg:
Student 类：

package com.qizekj.clazz;/*** @author chenqun* @date 2023/3/4 11:13*/
public class Student {private String name;private int age;private String stuNo;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getStuNo() {return stuNo;}public void setStuNo(String stuNo) {this.stuNo = stuNo;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +", stuNo='" + stuNo + '\'' +'}';}
}

获得Class的三种示例：

public class GetClassTest {public static void main(String[] args) {//第一种方式获取Class对象Student stu1 = new Student();//new 产生一个Student对象，一个Class对象。Class stuClass = stu1.getClass();//获取Class对象System.out.println(stuClass.getName());//第二种方式获取Class对象Class stuClass2 = Student.class;System.out.println(stuClass == stuClass2);//判断第一种方式获取的Class对象和第二种方式获取的是否是同一个//第三种方式获取Class对象try {Class stuClass3 = Class.forName("com.qizekj.clazz.Student");//注意此字符串必须是真实路径，就是带包名的类路径，包名.类名System.out.println(stuClass3 == stuClass2);//判断三种方式是否获取的是同一个Class对象} catch (ClassNotFoundException e) {e.printStackTrace();}}
}

注意，在运行期间，一个类，只有一个Class对象产生，所以打印结果都是true；

2、判断是否为某个类的示例

一般的，我们使用 instanceof 关键字来判断是否为某个类的实例。同时我们也可以借助反射中Class对象的 isInstance() 方法来判断是否为某个类的实例，他是一个native方法。

public native boolean isInstance(Object obj);

3、通过反射来生成对象的两种方法

（1）使用Class对象的 newInstance() 方法来创建Class对象对应类的实例。

eg：

public class Test02 {public static void main(String[] args) throws IllegalAccessException, InstantiationException, ClassNotFoundException {Class stuClass = Class.forName("com.qizekj.clazz.Student");Object student = stuClass.newInstance();System.out.println(student);}
}

（2）先通过Class对象获取指定的 Constructor 对象，再调用 Constructor 对象的 newInstance() 方法来创建对象，这种方法可以用指定的构造器构造类的实例。

public class Test02 {public static void main(String[] args) throws Exception {//获取Student的Class对象Class stuClass = Class.forName("com.qizekj.clazz.Student");//通过Class对象获取指定的Constructor构造器对象Constructor constructor=stuClass.getConstructor();//根据构造器创建实例：Object obj = constructor.newInstance();System.out.println(obj);}
}

4、通过反射获取构造方法并使用

（1）批量获取的方法：

public Constructor[] getConstructors(); // 获取所有"公有的"构造方法
public Constructor[] getDeclaredConstructors() // 获取所有的构造方法(包括私有、受保护、默认、公有)

（2）单个获取的方法，并调用：

public Constructor getConstructor(Class... parameterTypes) // 获取单个的"公有的"构造方法：
public Constructor getDeclaredConstructor(Class... parameterTypes) // 获取"某个构造方法"可以是私有的，或受保护、默认、公有；

（3）调用构造方法：

Constructor-->newInstance(Object... initargs)

• newInstance 是 Constructor类的方法（管理构造函数的类）
• api 的解释为：newInstance(Object… initargs) ，使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
• 它的返回值是T类型，所以newInstance是创建了一个构造方法的声明类的新实例对象，并为之调用。

eg：
Student类：共六个构造方法。

package com.cn.test;public class Student {//---------------构造方法-------------------//（默认的构造方法）Student(String str){System.out.println("(默认)的构造方法 s = " + str);}//无参构造方法public Student(){System.out.println("调用了公有、无参构造方法执行了。。。");}//有一个参数的构造方法public Student(char name){System.out.println("姓名：" + name);}//有多个参数的构造方法public Student(String name ,int age){System.out.println("姓名："+name+"年龄："+ age);//这的执行效率有问题，以后解决。}//受保护的构造方法protected Student(boolean n){System.out.println("受保护的构造方法 n = " + n);}//私有构造方法private Student(int age){System.out.println("私有的构造方法   年龄："+ age);}
}

public class ConstructorsTest {public static void main(String[] args) throws Exception {//1.加载Class对象Class clazz = Class.forName("com.qizekj.clazz.Student");//2.获取所有公有构造方法System.out.println("**********************获取所有公有构造方法*********************************");Constructor[] conArray = clazz.getConstructors();for(Constructor c : conArray){System.out.println(c);}System.out.println("************获取所有的构造方法(包括：私有、受保护、默认、公有)***************");conArray = clazz.getDeclaredConstructors();for(Constructor c : conArray){System.out.println(c);}System.out.println("*****************获取公有、无参的构造方法*******************************");Constructor con = clazz.getConstructor(null);//1>、因为是无参的构造方法所以类型是一个null,不写也可以：这里需要的是一个参数的类型，切记是类型//2>、返回的是描述这个无参构造函数的类对象。System.out.println("con = " + con);//调用构造方法Object obj = con.newInstance();System.out.println("******************获取私有构造方法，并调用*******************************");con = clazz.getDeclaredConstructor(char.class);System.out.println(con);//调用构造方法con.setAccessible(true);//暴力访问(忽略掉访问修饰符)obj = con.newInstance('男');}
}

打印结果：

5、获取成员变量并调用

（1）批量获取的方法：

Field[] getFields():  获取所有的"公有字段"；
Field[] getDeclaredFields():  获取所有字段，包括：私有、受保护、默认、公有；

（2）单个获取的方法，并调用：

public Field getField(String fieldName):  获取某个"公有的"字段；
public Field getDeclaredField(String fieldName):  获取某个字段(可以是私有的)。

（3）设置字段的值：

Field --> public void set(Object obj, Object value)

参数说明：

1. obj:要设置的字段所在的对象；
2. value:要为字段设置的值；

eg：
Student类：

package com.qizekj.clazz;/*** @author chenqun* @date 2023/3/5 16:49*/
public class Student2 {public String name;protected int age;char sex;private String phoneNum;public Student2(){}@Overridepublic String toString() {return "Student [name=" + name + ", age=" + age + ", sex=" + sex + ", phoneNum=" + phoneNum + "]";}
}

public class FieldsTest {public static void main(String[] args) throws Exception {//1.获取Class对象Class stuClass = Class.forName("com.qizekj.clazz.Student2");//2.获取字段System.out.println("************获取所有公有的字段********************");Field[] fieldArray = stuClass.getFields();for(Field f : fieldArray){System.out.println(f);}System.out.println("************获取所有的字段(包括私有、受保护、默认的)********************");fieldArray = stuClass.getDeclaredFields();for(Field f : fieldArray){System.out.println(f);}System.out.println("*************获取公有字段**并调用***********************************");Field f = stuClass.getField("name");System.out.println(f);//获取一个对象Object obj = stuClass.getConstructor().newInstance();//产生Student对象--》Student stu = new Student();//为字段设置值f.set(obj, "qizekj");//为Student对象中的name属性赋值--》stu.name = "qizekj"//验证Student2 stu = (Student2)obj;System.out.println("验证姓名：" + stu.name);System.out.println("**************获取私有字段****并调用********************************");f = stuClass.getDeclaredField("phoneNum");System.out.println(f);f.setAccessible(true);//暴力反射，解除私有限定f.set(obj, "18355555555");System.out.println("验证电话：" + stu);}
}

打印结果：

6、获取成员方法并调用

（1）批量获取的方法：

public Method[] getMethods():获取所有"公有方法"；（包含了父类的方法也包含Object类）；
public Method[] getDeclaredMethods():获取所有的成员方法，包括私有的(不包括继承的)

（2）单个获取的方法，并调用：

public Method getMethod(String name,Class... parameterTypes)

参数说明：

1. name : 方法名；
2. Class … : 形参的Class类型对象。

（3）调用方法：

Method --> public Object invoke(Object obj,Object... args)

参数说明：

1. obj : 要调用方法的对象；
2. args: 调用方式时所传递的实参。

Student类：

package com.qizekj.clazz;/*** @author chenqun* @date 2023/3/5 17:02*/
public class Student3 {//**************成员方法***************//public void show1(String s){System.out.println("调用了：公有的，String参数的show1(): s = " + s);}protected void show2(){System.out.println("调用了：受保护的，无参的show2()");}void show3(){System.out.println("调用了：默认的，无参的show3()");}private String show4(int age){System.out.println("调用了，私有的，并且有返回值的，int参数的show4(): age = " + age);return "abcd";}
}

public class MethodTest {public static void main(String[] args) throws Exception {//1.获取Class对象Class stuClass = Class.forName("com.qizekj.clazz.Student3");//2.获取所有公有方法System.out.println("***************获取所有的”公有“方法*******************");stuClass.getMethods();Method[] methodArray = stuClass.getMethods();for(Method m : methodArray){System.out.println(m);}System.out.println("***************获取所有的方法，包括私有的*******************");methodArray = stuClass.getDeclaredMethods();for(Method m : methodArray){System.out.println(m);}System.out.println("***************获取公有的show1()方法*******************");Method m = stuClass.getMethod("show1", String.class);System.out.println(m);//实例化一个Student对象Object obj = stuClass.getConstructor().newInstance();m.invoke(obj, "qizekj");System.out.println("***************获取私有的show4()方法******************");m = stuClass.getDeclaredMethod("show4", int.class);System.out.println(m);m.setAccessible(true);//解除私有限定Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参System.out.println("返回值：" + result);}
}

打印结果：

7、获取main方法并调用

Student类：

package com.qizekj.clazz;/*** @author chenqun* @date 2023/3/5 17:09*/
public class Student4 {public static void main(String[] args) {System.out.println("Student4的 main 方法执行了。。。");}
}

public class MainTest {public static void main(String[] args) {try {//1、获取Student对象的字节码Class clazz = Class.forName("com.qizekj.clazz.Student4");//2、获取main方法Method methodMain = clazz.getMethod("main", String[].class);//第一个参数：方法名称，第二个参数：方法形参的类型，//3、调用main方法// methodMain.invoke(null, new String[]{"a","b","c"});//第一个参数，对象类型，因为方法是static静态的，所以为null可以，第二个参数是String数组，这里要注意在jdk1.4时是数组，jdk1.5之后是可变参数//这里拆的时候将  new String[]{"a","b","c"} 拆成3个对象。。。所以需要将它强转。methodMain.invoke(null, (Object)new String[]{"a","b","c"});//方式一// methodMain.invoke(null, new Object[]{new String[]{"a","b","c"}});//方式二} catch (Exception e) {e.printStackTrace();}}
}

打印结果：

8、利用反射创建数值

数组在Java里是比较特殊的一种类型，它可以赋值给一个Object Reference。

public class Test03 {public static void main(String[] args) throws ClassNotFoundException {Class cls = Class.forName("java.lang.String");Object array = Array.newInstance(cls,25);//往数组里添加内容Array.set(array,0,"天天");Array.set(array,1,"小丽");Array.set(array,2,"阿奇");Array.set(array,3,"灰灰");Array.set(array,4,"莱德");//获取某一项的内容System.out.println(Array.get(array,3));}
}

9、通过反射运行配置文件内容

Student类：

package com.qizekj.clazz;/*** @author chenqun* @date 2023/3/5 17:18*/
public class Student5 {public void show(){System.out.println("is show()");}
}

配置文件 pro.txt 的内容：

className = com.qizekj.clazz.Student5
methodName = show

测试类：

package com.qizekj.clazz;import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Properties;/*** @author chenqun* @date 2023/3/5 17:19*/
public class Demo {public static void main(String[] args) throws Exception {//通过反射获取Class对象Class stuClass = Class.forName(getValue("className"));//"com.qizekj.clazz.Student5"//2获取show()方法Method m = stuClass.getMethod(getValue("methodName"));//show//3.调用show()方法m.invoke(stuClass.getConstructor().newInstance());}//此方法接收一个key，在配置文件中获取相应的valuepublic static String getValue(String key) throws IOException {Properties pro = new Properties();//获取配置文件的对象FileReader in = new FileReader("C:\\Users\\Administrator\\Desktop\\GitProjects\\chenqun_stu\\springstu\\src\\com\\qizekj\\clazz\\pro.txt");//获取输入流pro.load(in);//将流加载到配置文件对象中in.close();return pro.getProperty(key);//返回根据key获取的value值}
}

打印结果：

当我们升级这个系统时，不要Student5类，而需要新写一个Student6的类时，这时只需要更改 pro.txt 的文件内容就可以了。代码就一点不用改动。

10、通过反射越过泛型检查

泛型用在编译期，编译过后泛型擦除（消失掉），所以是可以通过反射越过泛型检查的。

package com.qizekj.clazz;import java.lang.reflect.Method;
import java.util.ArrayList;/*** @author chenqun* @date 2023/3/5 17:27*//** 通过反射越过泛型检查* 例如：有一个String泛型的集合，怎样能向这个集合中添加一个Integer类型的值？*/
public class Demo2 {public static void main(String[] args) throws Exception{ArrayList strList = new ArrayList<>();strList.add("aaa");strList.add("bbb");//strList.add(100);//获取ArrayList的Class对象，反向的调用add()方法，添加数据Class listClass = strList.getClass(); //得到 strList 对象的字节码 对象//获取add()方法Method m = listClass.getMethod("add", Object.class);//调用add()方法m.invoke(strList, 100);//遍历集合for(Object obj : strList){System.out.println(obj);}}
}

打印结果：