Java反射的前世今生
目录
一、反射是什么？
二、获取Class类对象的方式
1. Class.forName(String name)
2.类名.Class
3.对象.getClass()
4.综合代码
（1）实用类Person
(2)测试类 ReflectDemo1
5.Class类对象的获取-总结
三、Class对象的功能
1.获取成员变量
（1） Field[] getfields():
（2）Field getField(String name);
（3）Field[] getDeclaredFields()
（4）Field getDeclaredField(String name)
(5)获取成员变量代码总结
2.获取构造方法
（1）（带参）getConstructor（）
（2）无参构造方法----1
（3）无参构造方法----2
（4）获取构造方法代码总结
3.获取成员方法
（1）无参成员方法
（2）有参成员方法
（3）获取所有public修饰的方法
（4）获取方法名-获取类名
（5）获取成员方法代码总结
四、反射案例
1.加载配置文件
2.获取配置文件中定义的数据
3.反射 加载该类进入内存
4.创建对象
5.获取方法对象
6.执行方法
7.代码总结
一、反射是什么？
框架：是半成品软件，可以在框架的基础上进行软件开发，简化编码
反射：是框架设计的灵魂，将类的各个组成部分封装成其他对象，这就是反射机制
好处：1.可以在程序运行过程中，操作这些对象
2.可以解耦，提高程序的可扩展性。
**（耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立性)。）
Java代码在计算机中经历的三个阶段
源代码阶段 Class类对象阶段 运行时阶段
（还是在硬盘上没有进内存） （把个部分抽取出来封装成对象）
二、获取Class类对象的方式
1. Class.forName(String name)
用Class.forName(“全类名”)；得到Class类对象
//1.多用于配置文件
Class cls1 = Class.forName("cn.domain.Person");2.类名.Class
Class cls=类名.Class;
//2.参数的传递
Class cls2 = Person.class; 3.对象.getClass()
直接上代码把，更直观点
//3.多用于对象的获取字节码的方式
Person p=new Person();
Class cls3 = p.getClass();4.综合代码
（1）实用类Person
package cn.domain;
public class Person {
private String name;
private int age;
public String a;
protected String b;
String c;
private String d;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
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;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", a='" + a + '\'' +
", b='" + b + '\'' +
", c='" + c + '\'' +
", d='" + d + '\'' +
'}';
}
}
(2)测试类 ReflectDemo1
package cn.reflect;
import cn.domain.Person;
public class ReflectDemo1 {
public static void main(String[] args) throws ClassNotFoundException {
//1.多用于配置文件
Class cls1 = Class.forName("cn.domain.Person");
System.out.println(cls1);
//2.参数的传递
Class cls2 = Person.class;
System.out.println(cls2);
//多用于对象的获取字节码的方式
Person p=new Person();
Class cls3 = p.getClass();
System.out.println(cls3);
//三种方式获得的class对象 对象是同一个对象
}
}
5.Class类对象的获取-总结
同一个字节码文件（ .class）在一次程序运行的过程中，只会被加载一次（通过类加载器，加载入内存），无论通过那种方式获取，获取的类对象是同一个。
三、Class对象的功能
1.获取成员变量
（1） Field[] getfields():
获取类中所有public修饰的成员变量
//1.获取PersonClass 对象
Class personClass = Person.class;
//1.获取成员变量 Field[] getFields
Field[] fields = personClass.getFields();
for(Field field:fields)
{
System.out.println(field);
//什么也得不到 只会获取公共的成员变量(public) 没办法获取私有的
} （2）Field getField(String name);
获取指定的成员变量（获取对象后 get(),set() 方法）
Field a=personClass.getField("a");
Person p=new Person();
// Object o = a.get(p);
Object o = a.get(p);
System.out.println(o);获取后可以设置成员变量的值
Field a=personClass.getField("a");
Person p=new Person();
// Object o = a.get(p);
a.set(p,"100");
System.out.println(p);
Object o = a.get(p);
System.out.println(o);运行结果：
（3）Field[] getDeclaredFields()
获取类中所有的成员变量（不管修饰符）
Field[] declaredFields = personClass.getDeclaredFields();
for (Field de:declaredFields)
{
System.out.println(de);
}（4）Field getDeclaredField(String name)
获取指定的成员变量
Field d = personClass.getDeclaredField("d");
Object o1 = d.get(p);
System.out.println(o1);可以获取 我们可以想到也可以设置值 但是 又知道私有的是不能在类外被访问到其实在反射中是不存在私有公有的（需要暴力反射，忽略访问权限修饰符的安全检查）
这样执行会报错
这就是访问私有成员的结果，所以需要暴力反射
在获取Field对象后加了暴力反射代码赋值为true
Field d = personClass.getDeclaredField("d");
d.setAccessible(true);
Object o1 = d.get(p);
System.out.println(o1);
(5)获取成员变量代码总结
package cn.reflect;
import cn.domain.Person;
import java.lang.reflect.Field;
public class ReflectDemo2 {
public static void main(String[] args) throws Exception {
//1.获取PersonClass 对象
Class personClass = Person.class;
//1.获取成员变量 Field[] getFields
Field[] fields = personClass.getFields();
for(Field field:fields)
{
System.out.println(field);
//什么也得不到 只会获取公共的成员变量(public) 没办法获取私有的
}
System.out.println("----------------------");
Field a=personClass.getField("a");
Person p=new Person();
// Object o = a.get(p);
a.set(p,"100");
System.out.println(p);
Object o = a.get(p);
System.out.println(o);
System.out.println("---------2---------");
Field[] declaredFields = personClass.getDeclaredFields();
for (Field de:declaredFields)
{
System.out.println(de);
}
System.out.println("------------3------");
Field d = personClass.getDeclaredField("d");
d.setAccessible(true);
Object o1 = d.get(p);
System.out.println(o1);
}
}
2.获取构造方法
（1）（带参）getConstructor（）
getConstructor（） 是获取构造器的方法 返回的是构造器
构造方法是创建对象的
Constructor对象是 得到的是构造方法（构造器）
Class personClass = Person.class;
//获取类的构造方法
//返回一个构造器 参数为类
Constructor constructor = personClass.getConstructor(String.class,int.class);
System.out.println(constructor);
//Constructor对象是 得到的是构造方法
//构造方法是创建对象的
Person person = constructor.newInstance("zhangsan",19);
System.out.println(person); （2）无参构造方法----1
此方法先得到构造器对象
在通过构造器对象得到构造方法
Constructor constructor1 = personClass.getConstructor();
System.out.println(constructor1);
Person person1 = constructor1.newInstance();
System.out.println(person1); （3）无参构造方法----2
此方法通过Class对象直接调用方法
步骤得到简化 但是现在好像不建议使用
Person person2 = personClass.newInstance();
System.out.println(person2);（4）获取构造方法代码总结
package cn.reflect;
import cn.domain.Person;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class ReflectDemo3 {
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
Class personClass = Person.class;
//获取类的构造方法
//返回一个构造器 参数为类
Constructor constructor = personClass.getConstructor(String.class,int.class);
System.out.println(constructor);
//Constructor对象是 得到的是构造方法
//构造方法是创建对象的
Person person = constructor.newInstance("zhangsan",19);
System.out.println(person);
System.out.println("---------------------");
//空参构造
Constructor constructor1 = personClass.getConstructor();
System.out.println(constructor1);
Person person1 = constructor1.newInstance();
System.out.println(person1);
System.out.println("-----------------------");
Person person2 = personClass.newInstance();
System.out.println(person2);
System.out.println("------------------------");
Constructor personConstructor = personClass.getDeclaredConstructor(String.class, int.class);
Person nb = personConstructor.newInstance("nb", 19);
System.out.println(nb);
}
}
// 3.获取成员方法
（1）无参成员方法
先创建 Method 对象
还需要创建 Object 类对象 后边调用invoke（）方法需要用到
Class personClass = Person.class;
//Method 对象 是方法对象 无参不需要传参
Method eat = personClass.getMethod("eat");
//进行完这个需要创建个对象 后面方法需要调用
Person p=new Person();
//invoke(p) 若有参函数 则需要传入p 和他的参数
eat.invoke(p); （2）有参成员方法
在创建 Method 方法时 需要传入参数的类型
调用invoke时 传参需要先传入Object 类对象 再传入 参数值
Person p=new Person();
Method method = personClass.getMethod("eat", String.class);
method.invoke(p,"food");（3）获取所有public修饰的方法
这个获取的不光本类 还有它父类的
如果他不继承任何类 则只继承了 Object 类
获取时会获取Object 类的public修饰的成员方法和本类public修饰的成员方法
Method[] methods = personClass.getMethods();
for (Method method1:methods)
{
System.out.println(method1);
// method1.setAccessible(true);
}（4）获取方法名-获取类名
Method[] methods = personClass.getMethods();
for (Method method1:methods)
{
System.out.println(method1);
// method1.setAccessible(true); //获取方法名
String name = method1.getName();
System.out.println(name);
} String name = personClass.getName();
System.out.println(name);
（5）获取成员方法代码总结
package cn.reflect;
import cn.domain.Person;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectDemo4 {
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, ClassNotFoundException {
Class personClass = Person.class;
//Method 对象 是方法对象 无参不需要传参
Method eat = personClass.getMethod("eat");
//进行完这个需要创建个对象 后面方法需要调用
Person p=new Person();
//invoke(p) 若有参函数 则需要传入p 和他的参数
eat.invoke(p);
//有参成员方法
Method method = personClass.getMethod("eat", String.class);
method.invoke(p,"food");
System.out.println("---------------");
//获取所有public修饰的方法
Method[] methods = personClass.getMethods();
for (Method method1:methods)
{
System.out.println(method1);
// method1.setAccessible(true); //获取方法名
String name = method1.getName();
System.out.println(name);
}
System.out.println("-----------");
}
}
四、反射案例
需求：写一个“框架”，可以帮我们创建任意类的对象，并且执行其中任意方法
实现需求：
1.配置文件
2.反射
步骤：
1.将需要创建的对象的全类名和需要执行的方法定义在配置文件中
2.在程序中加载读取配置文件
3.使用反射技术加载类文件进内存
4.创建对象
5.执行方法
1.加载配置文件
1.1 创建 Properties 对象
1.2加载配置文件 ，转换为一个集合
1.2.1 获取class目录下的配置文件
//1.加载配置文件
//1.1 创建 Properties 对象
Properties pro=new Properties();
//1.2加载配置文件 ，转换为一个集合
//1.2.1 获取class目录下的配置文件
ClassLoader classLoader = Reflecttest.class.getClassLoader();//获取该字节码文件的类加载器 是由类加载器把字节码文件加载入内存的
InputStream resourceAsStream = classLoader.getResourceAsStream("pro.properties");//获取资源对应的资源流
pro.load(resourceAsStream);2.获取配置文件中定义的数据
String className = pro.getProperty("className");
String methodName = pro.getProperty("methodName");3.反射 加载该类进入内存
Class aClass = Class.forName(className);4.创建对象
Object o = aClass.newInstance();5.获取方法对象
Method method = aClass.getMethod(methodName);6.执行方法
method.invoke(o);7.代码总结
package cn.reflect;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;
/*
*框架类
* */
public class Reflecttest {
//可以创建任意类对象 可以执行任一方法
public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
//1.加载配置文件
//1.1 创建 Properties 对象
Properties pro=new Properties();
//1.2加载配置文件 ，转换为一个集合
//1.2.1 获取class目录下的配置文件
ClassLoader classLoader = Reflecttest.class.getClassLoader();//获取该字节码文件的类加载器 是由类加载器把字节码文件加载入内存的
InputStream resourceAsStream = classLoader.getResourceAsStream("pro.properties");//获取资源对应的资源流
pro.load(resourceAsStream);
//2.获取配置文件中定义的数据
String className = pro.getProperty("className");
String methodName = pro.getProperty("methodName");
//3.反射 加载该类进入内存
Class aClass = Class.forName(className);
//4.创建对象
Object o = aClass.newInstance();
//5.获取方法对象
Method method = aClass.getMethod(methodName);
//6.执行方法
method.invoke(o);
}
}