mzy对于反射的复习

    反射其实就是指在超脱规则的束缚，从强引用到弱相关，在上帝视角做事情，对于写配置文件，和一些框架的源码，得到调用上至关重要，java带有解释器的语法特性，使得泛型一类的语法糖和反射配合之后更如鱼得水！

    反射其实就是通过获得一个类的Class对象来进行操作，从而得到Constructor（构造方法：包括非共有；private、无类型、protected）对象、Method（方法：包括非共有；private、无类型、protected）对象和Field（变量，这个解释我也觉得不够准确：包括非共有；private、无类型、protected）对象来进行我们能够想象的所有操作！

 

Class类

得到类名称，类的实现的接口，继承类。

获得Class对象的三种方式：

1.类名.class;（依赖性较强，需要其中的import的支持）

Class c1 = Student.class;

2.Class.forName("全类名");（通过forName来加载，依赖性比较低）

Class c2 = Class.forName("c_flect.entity.Student");

3.对象.getClass();（一种单纯使用大多数时候，比较鸡肋的方法：通过对象来获得Class对类对象）

Class c3 = new Student().getClass();

常用方法：

getName()	获得全类名
getSimpleName()	仅获得当前类名
getSuperclass()	获得父类的名称（全类名）
getInterfaces()	返回值是Class[]数组，所有实现接口

 

涉及Constructor的

getConstructor	获取特定公开构造方法
getConstructors	获取所有公开构造方法
getDeclaredConstructor	获取特定的声明构造（包括非公开）
getDeclaredConstructors	获取所有的声明构造（包括非公开）

涉及Method的

getMethod	获取特定公开方法
getMethods	获取所有公开方法
getDeclaredMethod	获取特定的声明方法（包括非公开）
getDeclaredMethods	获取所有的声明方法（包括非公开）

涉及到Field的

getField	获取特定公开变量
getFields	获取所有公开变量
getDeclaredField	获取特定的声明变量（包括非公开）
getDeclaredFields	获取所有的声明变量（包括非公开）

其中需要注意的点：

1.所有如果是私有的构造方法、方法和变量要先setAccessible(true);才能进行使用

2.在get constructor、method和feild的时候，所有其中的形参类型，都是类型的.class Class对象

3.constructor最后newInstance就行了，method执行时调用invoke，field执行时调用set

4.method执行和field执行都要在执行方法的第一个位置传参传入执行此方法的对象（此方法的提供对象）

开始贴代码，使用junit测试：

package c_flect;

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

import org.junit.Test;

import c_flect.entity.Student;

/**
 * 反射复习：
 * 	Class类，代表类。
 * 		得到类名称，类的实现的接口，继承类。
 * 	Constructor类，代表类的构造方法。
 * 		构造对象。
 * 	Method类，代表类的普通方法。
 * 		调用方法。
 * 	Field类，代表类的属性。
 * 		得到属性值，设置属性值。
 * @author mzy
 */
public class Demo01 {
	/**
	 * Class类：
	 * 		测试得到Class类对象的三种方式回忆！		
	 */
	// @Test
	public void test01() throws  Exception {
		// 1.依赖性较强，需要其中的import的支持
		Class c1 = Student.class;
		// 2.通过forName来加载，依赖性比较低
		Class c2 = Class.forName("c_flect.entity.Student");
		// 3.一种单纯使用大多数时候，比较鸡肋的方法：通过对象来获得Class对类对象
		Class c3 = new Student().getClass();
		
		// 得到类名
		System.out.println(c1 == c2);
		System.out.println(c2 == c3);
		
		System.out.println(c1.getName()); // 得到类的全名
		System.out.println(c2.getSimpleName()); // 得到简单名
		// 得到类的继承的结构：得到当前的Student的父类
		System.out.println(c1.getSuperclass().getSimpleName()); 
		
		// 得到类的接口
		Class[] interArray = c1.getInterfaces();
		for (Class c : interArray) {
			System.out.println(c.getSimpleName());
		}
	}
	
	/**
	 * Constructor类：
	 * 		构造对象 
	 */
	@Test
	public void test02() throws Exception {
		// 通过Class类得到Constructor类
		Class c = Class.forName("c_flect.entity.Student");
		/*
		 *  获取所有的构造方法
		 *  但是获取到了所有的构造之后并并不好用，获取想要的才是最好的
		 *  统计有多少个构造方法可能有用。
		 */
		/*
		Constructor[] constructors = c.getConstructors();
		for(Constructor con : constructors) {
			System.out.println(con);
		}
		*/
		
		/*
		 * 1.调用无参构造
		 */
		Constructor cons1 = c.getConstructor(null);
		// 通过Constructor构造对象
		Object o1 = cons1.newInstance(null);
		// System.out.println(o1.getClass().getSimpleName());
		System.out.println(o1);
		/*
		 * 2.调用有参构造：私有
		 */
		Constructor cons2 = c.getDeclaredConstructor(int.class, String.class);
		// 设置这个私有构造的访问权限为true
		cons2.setAccessible(true);
		Object o2 = cons2.newInstance(19, "mzy");
		// System.out.println(o2.getClass().getSimpleName());
		System.out.println(o2);
	}
	
	/**
	 * Method类：
	 * 		类的普通方法，调用
	 */
	@Test
	public void test03() throws Exception {
		// 1.通过Class类 对象得到Method类对象
		Class c = Class.forName("c_flect.entity.Student");
		// Object o = c.getConstructor(null).newInstance(null);
		/*
		 * 同上：只有无参构造才可以这样简化！
		 * 有参构造必须 先getConstructor
		 * 再newInstance这种形式，或者
		 * getConstructor(int.class, String.class).newInstance(20, "mzy");
		 */
		Object o = c.newInstance();
	
		Method setName = c.getMethod("setName", String.class); // 如果有多个参数，跟在后面就行了
		/*
		 *  2) 通过Method对象来调用方法
		 *  	Method对象调用方法
		 *  	需要把要调用此方法的对象传入
		 *  	后面跟上参数值
		 */
		setName.invoke(o, "mzy");
		System.out.println(o);
		
		Constructor cons = c.getDeclaredConstructor(int.class, String.class, int.class);
		cons.setAccessible(true);
		
		Object o2 = cons.newInstance(18, "zxr", 168);
		Method getHeight = c.getDeclaredMethod("getHeight", null);
		getHeight.setAccessible(true);
		Object res = getHeight.invoke(o2, null);
		System.out.println("height = "+res);
		System.out.println(o2);
	}
	
	/**
	 * Field类：
	 * 		得到属性值，设置属性值。
	 */
	@Test
	public void test04() throws Exception {
		// 1) 通过Class得到Field类对象
		Class c = Class.forName("c_flect.entity.Student");
		// Object o = c.getConstructor(null).newInstance(null);
		Object o = c.newInstance();
		// 共有属性很简单，这里就演示非共有属性访问！
		Field field = c.getDeclaredField("name");
		field.setAccessible(true);
		field.set(o, "mzy");
		System.out.println(o);
	}
}

其中调用的Student类：

package c_flect.entity;

public class Student implements Person, Child{
	private int age;
	private String name;
	private int height;
	
	
	public Student() {
	
	}
	
	private Student(int age, String name) {
		this.age = age;
		this.name = name;
	}

	
	private Student(int age, String name, int height) {
		this.age = age;
		this.name = name;
		this.height = height;
	}


	public int getAge() {
		return age;
	}


	public void setAge(int age) {
		this.age = age;
	}


	public String getName() {
		return name;
	}


	public void setName(String name) {
		this.name = name;
	}


	private int getHeight() {
		return height;
	}


	public void setHeight(int height) {
		this.height = height;
	}


	@Override
	public String toString() {
		return "Student [age=" + age + ", name=" + name + "]";
	}
	
}