反射：框架设计的灵魂 -----Jane Eyre
框架：半成品软件。可以在框架的基础上进行软件开发，简化编码
反射：将类的各个组成部分封装为其他对象，这就是反射机制
概述:
通俗的说,所谓的反射,就是"在程序的运行过程中", 动态的获取到一个类的各个组成部分(成员变量, 成员方法, 构造方法...), 这就是反射机制.
可以将反射理解为对类的一种解刨, 可以解刨到类的心, 肝, 脾..等
解刨的一个类, 实际上就是解刨这个类的字节码文件.
好处：
1. 可以在程序运行过程中，操作这些对象。
2. 可以解耦，提高程序的可扩展性。
Java代码的三个阶段
获取Class对象的方式：
1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
* 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
2. 类名.class：通过类名的属性class获取
* 多用于参数的传递
3. 对象.getClass()：getClass()方法在Object类中定义着。
* 多用于对象的获取字节码的方式
* 结论：
同一个类的字节码文件(*.class)在一次程序运行过程中，只会被加载一次.
不论通过哪一种方式获取的Class对象都是同一个。代码演示：
public static void main(String[] args) throws Exception {
//1.Class.forName("全类名")。将字节码文件加载进内存，返回Class对象
Class cls1 = Class.forName("com.itheima_01.Person");
System.out.println(cls1); //class com.itheima_01.Person
//2.类名.class:通过类名的属性class获取
Class cls2 = Person.class;
System.out.println(cls2); //class com.itheima_01.Person
//3.对象.getClass：getClass()方法在Object类中定义
Person p = new Person();
Class cls3 = p.getClass();
System.out.println(cls3); //class com.itheima_01.Person
//使用==，判断是否是同一个对象
System.out.println(cls1==cls2); //true
System.out.println(cls1==cls3); //true
}Class对象功能：
* 获取功能：
1. 获取成员变量们
* Field[] getFields() ： //获取所有public修饰的成员变量
* Field getField(String name) //获取指定名称的public修饰的成员变量
* Field[] getDeclaredFields() //获取所有的成员变量，不考虑修饰符
* Field getDeclaredField(String name) //获取指定名称的成员变量，不考虑修饰符
2. 获取构造方法们
* Constructor[] getConstructors()
* Constructor getConstructor(Class... parameterTypes)
* Constructor getDeclaredConstructor(Class... parameterTypes)
* Constructor[] getDeclaredConstructors()
3. 获取成员方法们：
* Method[] getMethods()
* Method getMethod(String name, Class... parameterTypes)
* Method[] getDeclaredMethods()
* Method getDeclaredMethod(String name, Class... parameterTypes)
4. 获取全类名
* String getName() * Field：成员变量
* 操作：
1. 设置值
* void set(Object obj, Object value)
2. 获取值
* get(Object obj)
3. 忽略访问权限修饰符的安全检查
* Constructor:构造方法
* 创建对象：
* T newInstance(Object... initargs)
* 如果使用空参数构造方法创建对象，操作可以简化：
Class对象的newInstance方法
* setAccessible(true):暴力反射
* Method：方法对象
* 执行方法：
* Object invoke(Object obj, Object... args)
* 获取方法名称：
* String getName:获取方法名代码演示：
1.获取成员变量们
public static void main(String[] args) throws Exception {
/*
1. 获取成员变量们
* Field[] getFields() ： //获取所有public修饰的成员变量
* Field getField(String name) //获取指定名称的public修饰的成员变量
* Field[] getDeclaredFields() //获取所有的成员变量，不考虑修饰符
* Field getDeclaredField(String name) //获取指定名称的成员变量，不考虑修饰符
*/
//获取Person的class对象
Class personClass = Person.class;
//Field[] getFields() ： //获取所有public修饰的成员变量
Field[] fields = personClass.getFields();
//遍历fields数组
for (Field field : fields) {
System.out.println(field);
}
//Field getField(String name) //获取指定名称的public修饰的成员变量
Field a = personClass.getField("a");
System.out.println(a);
System.out.println("----------");
//获取成员变量a的值
Person p = new Person();
Object value1 = a.get(p);
System.out.println(value1);
//设置成员变量a的值
a.set(p, "张三");
System.out.println(p);
System.out.println("----------");
//Field[] getDeclaredFields() //获取所有的成员变量，不考虑修饰符
Field[] declaredFields = personClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
//Field getDeclaredField(String name) //获取指定名称的成员变量，不考虑修饰符
Field d = personClass.getDeclaredField("d");
//忽略访问权限修饰符的安全检查
d.setAccessible(true); //暴力反射
//获取d的值
Object value2 = d.get(p);
System.out.println(value2);
}2. 获取构造方法们
public static void main(String[] args) throws Exception {
/*
2. 获取构造方法们
* Constructor[] getConstructors()
* Constructor getConstructor(Class... parameterTypes)
* Constructor getDeclaredConstructor(Class... parameterTypes)
* Constructor[] getDeclaredConstructors()
*/
//获取Person的class对象
Class personClass = Person.class;
//Constructor getConstructor(Class... parameterTypes)
Constructor constructor = personClass.getConstructor(String.class, int.class);
System.out.println(constructor); //public cn.itcast.domain.Person(java.lang.String,int)
//创建对象
Object person = constructor.newInstance("张三", 23);
System.out.println(person); //Person{name='张三', age=23, a='null', b='null', c='null', d='null'}
System.out.println("-------------");
//Constructor[] getConstructors()
Constructor constructor1 = personClass.getConstructor();
System.out.println(constructor1); //public cn.itcast.domain.Person()
//创建空参对象
Object person1 = constructor1.newInstance();
System.out.println(person1); //Person{name='null', age=0, a='null', b='null', c='null', d='null'}
Object person2 = personClass.newInstance();
System.out.println(person2); //Person{name='null', age=0, a='null', b='null', c='null', d='null'}
} 3. 获取成员方法们
public static void main(String[] args) throws Exception {
/*
3. 获取成员方法们：
* Method[] getMethods()
* Method getMethod(String name, Class... parameterTypes)
* Method[] getDeclaredMethods()
* Method getDeclaredMethod(String name, Class... parameterTypes)
*/
//获取Person的class对象
Class personClass = Person.class;
//Method getMethod(String name, Class... parameterTypes) 获取指定方法名称
Method eat_Method1 = personClass.getMethod("eat");
System.out.println(eat_Method1);
Person p = new Person();
//执行方法
eat_Method1.invoke(p);
Method eat_Method2 = personClass.getMethod("eat",String.class);
eat_Method2.invoke(p,"饭");
System.out.println("-----------");
//Method[] getMethods() 获取所有public修饰的方法
Method[] methods = personClass.getMethods();
for (Method method : methods) {
System.out.println(method);
String name = method.getName();
System.out.println(name);
}
System.out.println("------------");
//4. 获取全类名 String getName()
String personName = personClass.getName();
System.out.println(personName); //com.itheima_01.Person
}案例：
* 需求：
写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法
* 实现条件：
1. 配置文件
2. 反射
* 实现步骤：
1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
2. 在程序中加载读取配置文件
3. 使用反射技术来加载类文件进内存
4. 创建对象
5. 执行方法代码演示：
public static void main(String[] args) throws Exception {
//创建类的加载器
//InputStream is = ReflectTest.class.getClassLoader().getResourceAsStream("pro.properties");
InputStream is = ReflectTest.class.getClassLoader().getResourceAsStream("pro.properties");
//创建Properties对象
Properties pro = new Properties();
pro.load(is);
//获取配置文件中的信息
String className = pro.getProperty("className");
String methodName = pro.getProperty("methodName");
//获取类的路径
Class cls = Class.forName(className);
//获取构造方法
Constructor constructor = cls.getConstructor(String.class,int.class);
//创建有参对象
Object o1 = constructor.newInstance("张三",23);
System.out.println(o1);
//创建无参对象
Object o = cls.newInstance();
System.out.println(o);
//获取方法
Method method = cls.getMethod("eat",String.class);
Method method1 = cls.getMethod("study");
//调用方法
method.invoke(o1,"馒头");
method1.invoke(o1);
}Person类
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;
}
// getter/setter 方法
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;
}
//重写toString方法
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", a='" + a + '\'' +
", b='" + b + '\'' +
", c='" + c + '\'' +
", d='" + d + '\'' +
'}';
}
//成员方法
public void eat() {
System.out.println("eat");
}
public void eat(String food) {
System.out.println("eat" + food);
}
public void sleep(){
System.out.println("好好休息");
}
pro.properties 配置文件
className=com.itheima_01.Student
methodName=study