反射技术

反射概述：
Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类，必须先要获取到该类的字节码文件对象。而解剖这个类，使用的就是Class类中的方法，所以先要获取到每一个字节码文件所对应的Class类型对象。
反射需要用到的成员及方法：

• Class 类
• Constructor 构造
• Method 方法
• Filed 字段
• instance 实例
• invoke 执行

准备
提供JavaBean，用于之后反射操作 JavaBean规范
1.提供私有字段，例如：private String id;
2.必须提供get或set方法 （可以使用快捷键生产，alt+shift+s）
3.提供无参构造方法
4.必须实现序列化接口 public class Bean implements java.io.Serializable

Bean类：

public class Bean implements java.io.Serializable {

	private String id;
	private String clssName;

	private Bean(String id) {
		super();
		this.id = id;
		System.out.println("这是有一个参数id的构造");
	}

	@Override
	public String toString() {
		return "Bean [id=" + id + ", clssName=" + clssName + "]";
	}

	private Bean(String id, String clssName) {
		super();
		this.id = id;
		this.clssName = clssName;
		System.out.println("这是有两个参数的构造");
	}

	public Bean() {
		System.out.println("这是无参构造");
	}

	// 方法
	public String getClssName() {
		return clssName;
	}

	public void setClssName(String clssName) {
		this.clssName = clssName;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public void show(String s1, int i) {
		System.out.println(s1 + "---" + i);
	}

	private void show(String s1) {
		System.out.println(s1);
	}

	public static void main(String[] args) {
		System.out.println("我是main方法");
	}
}

得到Class对象的三种方法及应用场景：

1. 通过类型获得 语法：类名.class 应用场景：确定类型 等 Class clazz1 = Bean.class;
2. 通过实例对象获得 语法：变量.getClass() 应用场景：在方法内部通过参数获得类型 等 Bean bean = newBean(); Class clazz2 = bean.getClass();
3. 通过字符串获得
   语法：Class.forName(“全限定类名”) 应用场景：通过配置获得字符串 等 Class clazz3 =
   Class.forName(“com.itheima_00_Bean.Bean”);

通过反射技述，使用Constructor对象实例对象：

得到构造方法对象，实例化对象
1.得到类
2.得到构造方法对象
3.实例化对象

import java.lang.reflect.Constructor;

import org.junit.Test;

public class ConstructorDemo {

	@Test
	public void demo() throws Exception {

		// 使用无参构造方法实例对象

		// 1.得到类
		Class clazz = Class.forName("com.reflect.Bean");

		// 2.得到构造方法对象
		Constructor cons = clazz.getConstructor();

		// 3.实例化对象
		cons.newInstance();

	}

	@Test
	public void demo2() throws Exception {

		// 使用有参构造方法实例对象

		// 1.得到类
		Class clazz = Class.forName("com.reflect.Bean");

		// 2.得到构造方法对象,指定对应形参类型
		Constructor cons = clazz.getConstructor(String.class);

		// 3.实例化对象，给定形参
		Object obj = cons.newInstance("b1001");

		System.out.println(obj);

	}

	@Test
	public void demo3() throws Exception {

		// 使用无参构造方法快速创建对象

		// 1.得到类
		Class clazz = Class.forName("com.reflect.Bean");

		// 2.直接实例化
		Object obj = clazz.newInstance();

		System.out.println(obj);

	}

	@Test
	public void demo4() throws Exception {

		// 使用private修饰的私有构造方法实列对象

		// 1.得到类
		Class clazz = Class.forName("com.reflect.Bean");

		// 2.得到构造方法对象
		// getConstructor() 得到指定参数的 、被public修饰的构造方法对象
		// getDeclaredConstructor()得到指定参数的 、全部的构造方法对象
		Constructor cons = clazz.getDeclaredConstructor(String.class, String.class);

		// 3.修改权限,设置可以访问私有数据 默认为false
		cons.setAccessible(true);

		// 4.实例化对象
		Object obj = cons.newInstance("b1002", "lisi");

		System.out.println(obj);

	}

}

反射操作成员方法：

步骤：

1. 创建实例对象。使用无参够着方法快速实例对象
2. 得到方法。使用getMethod(String name, 类<?>… parameterTypes) 返回一个 方法对象，它反映此表示的类或接口的指定公共成员方法 类对象
3. 执行方法。invoke(Object obj, Object… args)
   在具有指定参数的 方法对象上调用此 方法对象表示的底层方法。

import java.lang.reflect.Method;

import org.junit.Test;

public class MethodDemo {

	@Test
	public void demo() {

		// 一般使用类中方法
		Bean b = new Bean();
		b.setId("b001");
		String id = b.getId();
		System.out.println(id);

	}

	@Test
	public void demo2() throws Exception {

		// 创建对象，并执行setId()方法

		// 创建实例对象，使用无参够着方法快速实例对象
		Class clazz = Class.forName("com.reflect.Bean");
		Object obj = clazz.newInstance();

		// 得到方法
		// getMethod("setId", String.class) 得到方法，第一个参数为要得到的方法名，
		// 第二个参数为该方法的形参类型 为可变参数，可以是多个参数
		Method method = clazz.getMethod("setId", String.class);

		// 执行方法invoke(obj, "b002") 执行方法，第一个参数有为哪个对象执行，第二个参数为具体的实参
		method.invoke(obj, "b002");
		System.out.println(obj);
	}

	@Test
	public void demo3() throws Exception {

		// 创建对象，并执行setId()方法和getId()方法

		// 创建实例对象
		Class clazz = Class.forName("com.reflect.Bean");
		Object obj = clazz.newInstance();

		// 得到方法
		// getMethod("setId", String.class) 得到方法，第一个参数为要得到的方法名，
		// 第二个参数为该方法的形参类型 为可变参数，可以是多个参数
		Method method = clazz.getMethod("setId", String.class);
		Method method2 = clazz.getMethod("getId");

		// 执行方法invoke(obj, "b002") 执行方法，第一个参数有为哪个对象执行，第二个参数为具体的实参
		method.invoke(obj, "b002");
		String str = (String) method2.invoke(obj);

		System.out.println(str);
	}

	@Test
	public void demo4() throws Exception {

		// 执行有多个参数的方法

		// 创建实例对象
		Class clazz = Class.forName("com.reflect.Bean");
		Object obj = clazz.newInstance();

		// 得到方法
		// getMethod() 得到方法，
		// "" 第一个参数为要得到的方法名，
		// String.class int.class 第二个参数为该方法的形参类型 为可变参数，可以是多个参数
		Method method2 = clazz.getMethod("show", String.class, int.class);

		method2.invoke(obj, "sb", 2);
		System.out.println(obj);
	}

	@Test
	public void demo5() throws Exception {

		// 暴力反射，执行私有方法

		// 创建实例对象
		Class clazz = Class.forName("com.reflect.Bean");
		Object obj = clazz.newInstance();

		// 得到方法
		// getMethod() 得到方法，
		// "" 第一个参数为要得到的方法名，
		// String.class int.class 第二个参数为该方法的形参类型 为可变参数，可以是多个参数
		Method method2 = clazz.getDeclaredMethod("show", String.class);

		// 修改权限
		method2.setAccessible(true);

		method2.invoke(obj, "hello private");
		System.out.println(obj);
	}

	@Test
	public void demo6() throws Exception {

		// 执行静态方法main()
		// 注意：可变参数在执行时，JVM会将其实参数组打散成多个参数
		// 1.静态方法执行不需要对象
		// 2.参数为数组时的处理办法：a.将数组转换成Object b.传递一个二维数组，将二维数组的第一个数据变成要传递的数组
		// new Object[]{args}

		// 创建实例对象
		Class clazz = Class.forName("com.reflect.Bean");
		Object obj = clazz.newInstance();

		// 得到main方法,参数为字符串数组
		Method method = clazz.getDeclaredMethod("main", String[].class);

		// 执行方法
		String[] args = { "aaa", "bb", "c" };
		method.invoke(null, (Object) args);
		method.invoke(null, new Object[] { args });
	}

}