反射

类的生命周期

什么是反射？

反射：框架的灵魂
框架：半成品软件。在框架的基础上进行开发，可以简化我们的编码。
反射：将类的各个组成部分封装成其他对象，这就是反射机制

好处：
1.在程序的运行过程中，来操作这些对象。
2.可以解耦，提高程序的可扩转性

String str = "123";
str.

我们对 . 出很多的方法，这其实就是内部就是使用的是反射机制，你定义了一个字符串，那么他会把字符串的字节码文件加载进内存，在内存当中有一个class类对象，class对象已将所有的方法都抽取出来封装在method[]数组当中，所以我们能够 . 出这么多的程序。

获取class对象的方式

1.Class.forName(“全类名”)

将字节码文件加载进内存，返回class对象
多用于配置文件，将类名定义在配置文件当中，读取文件，加载类

2.类名.class

通过类名的class获取
多用于参数的传递

3.对象.getClass()

getClass()方法在object类当中定义着
多用于对象获取字节码的方式

实操分析

（所有非public类型对象，都需要）
首先定义一个person类,内部定义好成员变量，构造方法和成员方法

public class Person {
	
	private String nameString;
	private int age;
	
	public Person() {
		
	}
	
	public Person(String nameString, int age) {
		this.nameString = nameString;
		this.age = age;
	}

	public String getNameString() {
		return nameString;
	}

	public void setNameString(String nameString) {
		this.nameString = nameString;
	}

	public int getAge() {
		return age;
	}

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

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

}

定义测试类

public class refulectDemo1 {
	
	/**
	 *      1.Class.forName("全类名")：将字节码文件加载进内存，返回class对象
		2.类名.class:通过类名的class获取
		3.对象.getClass(): getClass()方法在object类当中定义着
	 * @throws ClassNotFoundException 
	 */
	public static void main(String[] args) throws Exception {
		// 1.Class.forName("全类名")：
		Class class1 = Class.forName("reflect.Person");
		System.out.println(class1);
		
		//2.类名.class:通过类名的class获取
		Class class2 = Person.class;
		System.out.println(class2);
		
		//3.对象.getClass()
		Person person = new Person();
		Class class3 = person.getClass();
		System.out.println(class3);
		
	}

}

用 == 进行比较

System.out.println(class1 == class2);
System.out.println(class2 == class3);

输出为：

true
true

结论：
同一类加载器加载的文件（*.class）在一次程序运行过程中，只会被加载一次，不论你通过那种方式获取的class对象都是同一个。

实际应用

（所有非public类型对象，都需要使用暴力反射）
1.获取成员变量们

1.Field[] getFields() ：获取所有public修饰的成员变量 
2.Field getField(String name)：获取指定名称的
3.Field[] getDeclaredFilds()：获取所有的成员变量，不考虑修饰符
4.Field getDeclaredField(String name)

2.获取构造方法们

1.Constructor<?>[] getConstructors()
2.Constructor<T> getConstructor(类<?>...parameterTypes)
3.Constructor<?>[] getDeclaredConstructors()
4.Constructor<T> getDeclaredConstructors(类<?>...parameterTypes)

3.获取方法名

1.Method[] getMethod()
2.Method getMethod(String name,类<?>... parameterTypes)
3.Method[] getDeclaredMethod()
4.Method getDeclaredMethod(String name,类<?>... parameterTypes)

4.获取类名

String getName()

Field成员变量

操作
1.设置值
void set(Object obj,Object value)
2.获取值
get(Object obj)
3.忽略安全访问修饰符的安全检查
setAccessible(true) //暴力反射 private

首先获取类对象

 //0.获取Person的Class对象
        Class personClass = Person.class;

获取所有public类型成员变量，并输出。

   //1.Field[] getFields()获取所有public修饰的成员变量
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

获取所有的成员变量，不考虑修饰符

 //Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符
        Field[] declaredfie=personClass.getDeclaredFields();
        for (Field declaredField : declaredfie) {
            System.out.println(declaredField);
        }

获取成员变量的值
首先要实例化一个对象，否则没有开辟存储空间。
这四句话的意思分别是，得到叫name的成员变量对象，
实例化一个对象，成员变量也会被初始化，
成员变量对象.get（实例化对象名字），得到的值用Object类型接收。

		//2.Field getField(String name)
        Field fiename= personClass.getField("name");
		Person p = new Person();
        Object value = fiename.get(p);
        System.out.println(value);

若成员变量是私有的
需要用到成员变量对象.setAccessible(true) //暴力反射

  		//Field getDeclaredField(String name)
        Field fiename = personClass.getDeclaredField("name");
        Person p = new Person();
        //忽略访问权限修饰符的安全检查
        fiename.setAccessible(true);//暴力反射
        Object value2 = fiename.get(p);
        System.out.println(value2);

同理set值也是这样，可以为成员变量赋值。
set函数第一个参数是实例化的对象名，第二个是获取的成员变量对象想要赋的值。

fiename.set（p,"张三"）

Constructor访问构造方法

创建对象
T newInstance(Object… initarges)
如果使用空参数构造方法，此操作可以简化：class对象的newInstance方法

类对象.getConstructor获取构造方法对象。
构造方法对象.newInstance(“张三”,20)，用Object类型接收。

		//0.获取Person的class对象
		Class personClass = Person.class;
		//因为构造器的方法名称是相同的，不同的是参数列表，所以我们可以根据不同的参数列表来找到构造器
		Constructor constructor = personClass.getConstructor(String.class,int.class);
		System.out.println(constructor);
		//创建对象
		Object perObject = constructor.newInstance("张三",20);
		System.out.println(perObject);

Method:方法对象

执行方法
object invoke(Object object,Object… ages)
获取方法名称
String getName:获取方法名

类对象.getMethod(“方法名”) 得到方法对象。
实例化一个对象，
方法对象.invoke（实例化对象名字）执行方法。
需要注意的是，如果方法有参数，需要在getMethod后边加一个参数类型。

		//0.获取Person的class对象
		Class personClass = Person.class;
		
		//获取指定名称的方法,方法无参
		Method eat_method = personClass.getMethod("eat");
		//执行方法
		Person person =new Person();
		eat_method.invoke(person);
		
		//获取指定名称的方法，方法有参
		Method eat_method1 = personClass.getMethod("eat",String.class);
		//执行方法
		eat_method1.invoke(person,"饭");
		
		//获取所有public修饰的方法
		Method[] methods = personClass.getMethods();
		for (Method method : methods) {
			System.out.println(method);
			//获取方法的名称
			String name = method.getName();
			System.out.println(name);
		}