反射

1、概念：将类的各个组成部分封装为其他对象，这就是反射机制。

2、在Class类对象里面：成员变量封装成Field对象；构造方法封装成Constructor对象；成员方法封装成Method对象。

3、java代码在计算机中经历的三个阶段：Source源代码阶段、Class类对象阶段、Runtime运行时阶段。

再回过头来看反射的定义，将成员变量封装成Field对象、将构造方法封装成Constructor对象、将成员方法封装成Merhods对象等过程就是反射的过程。

4、获取字节码Class对象的三种方式

// 1.Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
      Class class1 = Class.forName("first.Person");// 包名.类名
        

// 2.类名.class：通过类名的class属性获取
      Class class2 = Person.class;
        

// 3.对象.getClass()：getClass()方法在Object类中定义
      Person person = new Person();

      Class class3 = person.getClass();

5、Class对象获取成员变量（5--8所有类都在包first里面）

Person.java

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;
	}
}

Reflect.java

import java.lang.reflect.Field;

public class Reflect {

	public static void main(String[] args) throws Exception {
		//0.获取Person的Class对象
		Class personClass = Person.class;
		
		//1.获取成员变量
		//(1)Field[] getFields() 获取所有public修饰的成员变量
		Field[] fields = personClass.getFields();
		for(Field field : fields) {
			System.out.println(field);
		}
		
		//(2)Field getField(String name) 获取指定名称的public修饰的成员变量
		Field a = personClass.getField("a");
		//获取成员变量a的值
		Person p = new Person();
		Object value = a.get(p);
		System.out.println(value); // null
		//设置a的值
		a.set(p, "Jack");
		System.out.println(p.a); // Jack
		
		//(3)Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
		Field[] declaredFields = personClass.getDeclaredFields();
		for(Field declaredField : declaredFields) {
			System.out.println(declaredField);
		}
		
		//(4)Field getDeclaredField(String name) 获取指定名称的成员变量
		Field d = personClass.getDeclaredField("d");
		d.setAccessible(true); // 暴力反射：忽略访问权限修饰符的安全检查，即private也可访问。不加这句，下一行会报错。
		System.out.println(d.get(p));
	}
}

6、Class对象获取构造方法

Person.java同上

Reflect.java

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

public class Reflect {

	public static void main(String[] args) throws Exception {
		//0.获取Person的Class对象
		Class personClass = Person.class;
		
		/*
		 *Constructor<?>[] getConstructors()
		 *Constructor<T> getConstructor()
		 *
		 *Constructor<?>[] getDeclaredConstructors()
		 *Constructor<T> getDeclaredConstructor()
		 */
		
		Constructor constructor = personClass.getConstructor(String.class, int.class);
		System.out.println(constructor);
		//创建对象
		Object p1 = constructor.newInstance("Jack", 25); // 有实际参数
		Object p2 = constructor.newInstance(); // 空参
		
		Object obj = personClass.newInstance(); // Class对象直接创建空参对象
	}
}

7、Class对象获取成员方法+获取类名

Person.java

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;
	}
	
	public void eat() {
		System.out.println("eat...");
	}
	
	public void eat(String food) {
		System.out.println("eat..." + food);
	}
}

Reflect.java

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Reflect {

	public static void main(String[] args) throws Exception {
		//0.获取Person的Class对象
		Class personClass = Person.class;
		
		/*
		 *Method[] geMethods()
		 *Method geMethod()
		 *
		 *Method[] getDeclaredMethods()
		 *Method getDeclaredMethod()
		 */
		
		Method e1 = personClass.getMethod("eat"); // 空参
		Person p = new Person();
		//执行方法
		e1.invoke(p);
		
		Method e2 = personClass.getMethod("eat", String.class); // 有实际参数
		//执行方法
		e2.invoke(p, "lunch");
		
		//获取所有public修饰的方法
		Method[] methods = personClass.getMethods();
		for(Method method : methods) { // 不仅仅有Person的方法，还有Object的方法
			System.out.println(method);
			// 获取方法名
			String name = method.getName();
			System.out.println(name);
		}
		
		// 获取类名
		String className = personClass.getName();
		System.out.println(className); // 包名.类名
	}
}

8、案例

要求：

①设计一个“框架”（当然不是真正的框架），在不改变该类的任何代码的前提下，可以创建任意类的对象，可以执行任意方法。

Person.java

package first;

public class Person {
	public void eat() {
		System.out.println("eat...");
	}
}

配置文件：pro.properties

className = first.Student
methodName = sleep

ReflectTest.java

package first;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

public class ReflectTest {
	public static void main(String[] args) throws Exception {
		// 可以创建任意类的对象，可以执行任意方法
		// 前提：不改变该类的任何代码
		
		// 1.加载配置文件
		// 1.1创建Properties对象
		Properties pro = new Properties();
		// 1.2加载配置文件，转换为一个集合
		ClassLoader classLoader = ReflectTest.class.getClassLoader();
		InputStream is = classLoader.getResourceAsStream("pro.properties");
		pro.load(is);
		
		// 2.获取配置文件中定义的数据
		String className = pro.getProperty("className");
		String methodName = pro.getProperty("methodName");
		
		// 3.加载该类进内存
		Class cls = Class.forName(className);
		
		// 4.创建对象
		Object obj = cls.newInstance();
		
		// 5.获取方法对象
		Method method = cls.getMethod(methodName);
		
		// 6.执行对象
		method.invoke(obj);
	}
}