相关链接；
https://blog.csdn.net/qq_36226453/article/details/82790375
https://blog.csdn.net/qq_45661125/article/details/114317185
对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。（反射就是把java类中的各种成分映射成一个个的Java对象）
要想解剖一个类,必须先要获取到该类的字节码文件对象，所以先要获取到每一个字节码文件对应的Class类型的对象.（Class对象的由来是将class文件读入内存，并为之创建一个Class对象。）
1、反射机制的功能：
Java反射机制主要提供了以下功能：
- 在运行时判断任意一个对象所属的类。
- 在运行时构造任意一个类的对象。
- 在运行时判断任意一个类所具有的成员变量和方法。
- 在运行时调用任意一个对象的方法。
- 生成动态代理
2、获取Class对象的三种方式
1.1 Object ——> getClass();
Student stu1 = new Student();//这一new 产生一个Student对象，一个Class对象。 Class stuClass = stu1.getClass();//获取Class对象 System.out.println(stuClass.getName());
1.2 任何数据类型（包括基本数据类型）都有一个“静态”的class属性
Class stuClass2 = Student.class;
1.3 通过Class类的静态方法：forName（String className）(常用)
Class stuClass3 = Class.forName("fanshe.Student");//注意此字符串必须是真实路径，就是带包名的类路径，包名.类名注意：在运行期间，一个类，只有一个Class对象产生。
3、通过反射获取构造方法并使用：
通过Class对象可以获取某个类中的：构造方法、成员变量、成员方法；并访问成员；
1.获取构造方法：
1).批量的方法：
public Constructor[] getConstructors()//所有"公有的"构造方法
public Constructor[] getDeclaredConstructors()//获取所有的构造方法(包括私有、受保护、默认、公有)
2).获取单个的方法，并调用：
public Constructor getConstructor(Class... parameterTypes)//获取单个的"公有的"构造方法：
public Constructor getDeclaredConstructor(Class... parameterTypes)//获取"某个构造方法"可以是私有的，或受保护、默认、公有；
2、调用构造方法：
Constructor-->newInstance(Object... initargs)
//1.加载Class对象
Class clazz = Class.forName("fanshe.Student");
//2.获取所有公有构造方法
Constructor[] conArray = clazz.getConstructors();//所有"公有的"构造方法
for(Constructor c : conArray){
System.out.println(c);
}
conArray = clazz.getDeclaredConstructors();//所有的构造方法(包括：私有、受保护、默认、公有)
for(Constructor c : conArray){
System.out.println(c);
}
Constructor con = clazz.getConstructor(null);//获取公有、无参的构造方法
//1>、因为是无参的构造方法所以类型是一个null,不写也可以：这里需要的是一个参数的类型，切记是类型
//2>、返回的是描述这个无参构造函数的类对象。
//调用构造方法
Object obj = con.newInstance();
// Student stu = (Student)obj;
con = clazz.getDeclaredConstructor(char.class);//获取私有构造方法
//调用构造方法
con.setAccessible(true);//暴力访问(忽略掉访问修饰符)
obj = con.newInstance('男');
}4、获取成员变量并调用
package fanshe.field;
import java.lang.reflect.Field;
获取成员变量并调用：
1.批量的
1).Field[] getFields():获取所有的"公有字段"
2).Field[] getDeclaredFields():获取所有字段，包括：私有、受保护、默认、公有；
2.获取单个的：
1).public Field getField(String fieldName):获取某个"公有的"字段；
2).public Field getDeclaredField(String fieldName):获取某个字段(可以是私有的)
设置字段的值：
Field --> public void set(Object obj,Object value):
参数说明：
1.obj:要设置的字段所在的对象；
2.value:要为字段设置的值；
public class Fields {
public static void main(String[] args) throws Exception {
//1.获取Class对象
Class stuClass = Class.forName("fanshe.field.Student");
//2.获取字段
Field[] fieldArray = stuClass.getFields();
for(Field f : fieldArray){
System.out.println(f);
}
fieldArray = stuClass.getDeclaredFields();
for(Field f : fieldArray){
System.out.println(f);
}
Field f = stuClass.getField("name");
System.out.println(f);
//获取一个对象
Object obj = stuClass.getConstructor().newInstance();//产生Student对象--》Student stu = new Student();
//为字段设置值
f.set(obj, "刘德华");//为Student对象中的name属性赋值--》stu.name = "刘德华"
//验证
Student stu = (Student)obj;
System.out.println("验证姓名：" + stu.name);
f = stuClass.getDeclaredField("phoneNum");
System.out.println(f);
f.setAccessible(true);//暴力反射，解除私有限定
f.set(obj, "18888889999");
System.out.println("验证电话：" + stu);
}
}由此可见，调用字段时，需要传递两个参数：
Object obj = stuClass.getConstructor().newInstance();
//产生Student对象--》Student stu = new Student();
//为字段设置值
f.set(obj, "刘德华");//为Student对象中的name属性赋值--》stu.name = "刘德华"
第一个参数：要传入设置的对象，第二个参数：要传入实参
5、获取成员方法并调用
package fanshe.method;
import java.lang.reflect.Method;
获取成员方法并调用：
1.批量的：
public Method[] getMethods():获取所有"公有方法"；（包含了父类的方法也包含Object类）
public Method[] getDeclaredMethods():获取所有的成员方法，包括私有的(不包括继承的)
2.获取单个的：
public Method getMethod(String name,Class<?>... parameterTypes):
参数：
name : 方法名；
Class ... : 形参的Class类型对象
public Method getDeclaredMethod(String name,Class<?>... parameterTypes)
调用方法：
Method --> public Object invoke(Object obj,Object... args):
参数说明：
obj : 要调用方法的对象；
args:调用方式时所传递的实参；
):
public class MethodClass {
public static void main(String[] args) throws Exception {
//1.获取Class对象
Class stuClass = Class.forName("fanshe.method.Student");
//2.获取所有公有方法
stuClass.getMethods();
Method[] methodArray = stuClass.getMethods();
for(Method m : methodArray){
System.out.println(m);
}
methodArray = stuClass.getDeclaredMethods();
for(Method m : methodArray){
System.out.println(m);
}
Method m = stuClass.getMethod("show1", String.class);
System.out.println(m);
//实例化一个Student对象
Object obj = stuClass.getConstructor().newInstance();
m.invoke(obj, "刘德华");
m = stuClass.getDeclaredMethod("show4", int.class);
System.out.println(m);
m.setAccessible(true);//解除私有限定
Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参
System.out.println("返回值：" + result);
}
}由此可见，m = stuClass.getDeclaredMethod("show4", int.class);//调用制定方法（所有包括私有的），需要传入两个参数，第一个是调用的方法名称，第二个是方法的形参类型，切记是类型。
Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参
6、反射main方法
package fanshe.main;
import java.lang.reflect.Method;
/**
* 获取Student类的main方法、不要与当前的main方法搞混了
*/
public class Main {
public static void main(String[] args) {
try {
//1、获取Student对象的字节码
Class clazz = Class.forName("fanshe.main.Student");
//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();
}
}
}7、反射方法的其它使用之---通过反射运行配置文件内容
public class Student {
public void show(){
System.out.println("is show()");
}
}
配置文件以txt文件为例子（pro.txt）：
className = cn.fanshe.Student
methodName = show
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Properties;
/*
* 我们利用反射和配置文件，可以使：应用程序更新时，对源码无需进行任何修改
* 我们只需要将新类发送给客户端，并修改配置文件即可
*/
public class Demo {
public static void main(String[] args) throws Exception {
//通过反射获取Class对象
Class stuClass = Class.forName(getValue("className"));//"cn.fanshe.Student"
//2获取show()方法
Method m = stuClass.getMethod(getValue("methodName"));//show
//3.调用show()方法
m.invoke(stuClass.getConstructor().newInstance());
}
//此方法接收一个key，在配置文件中获取相应的value
public static String getValue(String key) throws IOException{
Properties pro = new Properties();//获取配置文件的对象
FileReader in = new FileReader("pro.txt");//获取输入流
pro.load(in);//将流加载到配置文件对象中
in.close();
return pro.getProperty(key);//返回根据key获取的value值
}
}当我们升级这个系统时，不要Student类，而需要新写一个Student2的类时，这时只需要更改pro.txt的文件内容就可以了。代码就一点不用改动。
8、反射方法的其它使用之---通过反射越过泛型检查
泛型用在编译期，编译过后泛型擦除（消失掉）。所以是可以通过反射越过泛型检查的。
import java.lang.reflect.Method;
import java.util.ArrayList;
/*
* 通过反射越过泛型检查
* 例如：有一个String泛型的集合，怎样能向这个集合中添加一个Integer类型的值？
*/
public class Demo {
public static void main(String[] args) throws Exception{
ArrayList<String> 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);//aaa、bbb、100
}
}
}
京公网安备 11010502036488号