反射如何创建对象以及反射的功能与实例（认真总结知识）

反射：将类的各个组成部分封装为其他对象，这就是反射机制
反射的好处：
1、可以在程序运行过程中，操作这些对象。
2、可以解耦，提高程序可扩展性。

基础知识：Java代码在 计算机中 经历的阶段：三个阶段

第一个阶段：
我们编写代码的时候，创建了一个Preson类。里面有自己的成员变量，构造方法和成员方法。然后我们是不能直接运行的，都知道要先经过Javac编译，编译完成后会形成一个字节码文件，就是.class文件。class文件里有哪些内容呢？它把Java文件提取了出来，有成员变量，有构造方法和成员方法 三个重要部分，里面不只有这三部分，还有类的名称等等信息。因为Java和class文件都是在硬盘上存储着的，所以这个阶段成为source源代码阶段。如何将字节码文件加载进内存呢？这就是第二个阶段

第二个阶段：Class类对象阶段
类加载器（ClassLoader）,将字节码加载到内存，如何描述字节码.class文件的内容呢。这里运用了对象来描述字节码文件，取了个名字就叫做Class类对象，用对象来描述出class字节码里面的内容。类对象里面又分成员变量，构造方法和成员方法。类对象还可以获取接口。成员变量可以用来 拿到值，设置值。构造方法可以创建对象。成员方法可以运行执行。每个部分都可以封装为对象，对象不只一个，多个可以形成数组。最后可以通过Class对象的行为创建Person对象或者student对象

第三个阶段：Runtime运行时阶段
想要创建对象，就要先获取到Class类对象

如何获取Class对象的方式：

为什么有三种方式呢？ 可以理解为每个阶段都对应一种
1、Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象
*多用于配置文件，将类名定义在配置文件中。读取文件，加载类
2、类名.class ： 通过类名的属性class获取
*多用于参数传递
3、对象.getClass（）：getClass（）方法在Object类中定义
*多用于对象的获取字节码的方式

总结：获取Class对象的三个方式：全类名、类名、对象

代码示例：

public static void main(String[] args) throws ClassNotFoundException {
		
		//1.Class.forName("全类名")，包名.类名
		Class cls1 = Class.forName("domain.Person");
		System.out.println(cls1);
		
		//2、类名.class ： 通过类名的属性class获取
		Class cls2= Person.class;
		System.out.println(cls2);
		//对象.getClass（）
		Person person = new Person();
		Class<? extends Person> cls3 = person.getClass();
		System.out.println(cls3);
		
		//判断这几个是否相等，地址相等则相等
		System.out.println(cls1 == cls2);
		System.out.println(cls1 == cls3);
		

结果：是相等的

结论：同一个字节码文件在一次程序运行过程中，只会被加载一次，不管通过哪一个方式获取到Class对象都是同一个

获取到的Class对象有什么用呢？Class对象功能介绍：

获取的功能：
		  Class对象功能：
         * 获取功能：
	 1. 获取成员变量们*
	  * Field[] getFields()
	* Field getField(String name)

         * Field[] getDeclaredFields()
         * Field getDeclaredField(String name)
     **2. 获取构造方法们**
         * Constructor<?>[] getConstructors()
         * Constructor<T> getConstructor(类<?>... parameterTypes)

         * Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
         * Constructor<?>[] getDeclaredConstructors()
     3. 获取成员方法们：
         * Method[] getMethods()
         * Method getMethod(String name, 类<?>... parameterTypes)

         * Method[] getDeclaredMethods()
         * Method getDeclaredMethod(String name, 类<?>... parameterTypes)

     4. 获取类名
         * String getName()

对每个方法进行细分：

Field[] getFields()：获取所有public修饰的成员变量，但private修饰的获取不到
Field getField(String name)：获取指定名称修饰的成员变量

	public static void main(String[] args) {
		
		//获取Person的Class对象
		Class<Person> personClass = Person.class;
		
		//获取成员变量 getFields()
		Field[] fields = personClass.getFields();
		
		for(Field field : fields) {
			System.out.println(field);
		}
		
	}

结果：

上面的代码是获取public修饰的所有成员变量，下面是获取成员的某个（具体的）变量，先获得某个成员变量，然后使用get（）获取值。get函数里需要一个对象作为参数，所以创建了一个对象。小结：先获取成员中某个成员变量，再获取该成员的值，调用类对象的方法getField获取

Field fi=personClass.getField("a");
		//获取成员变量a 的值
		Person p = new Person();
		Object reslut = fi.get(p);//但是get里面需要传入一个对象，不得已创建了p
		System.out.println(reslut);
		//设置成员变量的值
		fi.set(p, "张三");//也是需要指定对象的，这里是p
		System.out.println(p);

成功输出结果：

对于

 Field[] getDeclaredFields()
 Field getDeclaredField(String name)

方法，比上面方法多了修饰符Declared，它们之前有什么区别呢？？？？

先讲区别吧，就是获取的成员变量不管是什么类型的都可以获取，多了修饰符Declared的方法连private对象也可以获取

Field[] declaredFields=personClass.getDeclaredFields();
		for(Field declaredField : declaredFields) {//循环遍历
				System.out.println(declaredField);
		}

输出结果。可以看到获取到private对象c,可以获取私有对象？？？？

接下来对私有变量c进行设置值：

Field c	= personClass.getDeclaredField("c");
		c.get(p);//获取值
		c.set(p, "李四");//设置值
		System.out.println(c);

输出结果报错显示不能访问：

Exception in thread "main" java.lang.IllegalAccessException: class com.it.reflect.ReflectDemo02 cannot access a member of class domain.Person with modifiers "private"

怎么办呢？它不让访问！！！怎么办？不能惯着它！！！！
使用一招：暴力反射

c.setAccessible(true);//暴力反射

Field c	= personClass.getDeclaredField("c");
		//忽略访问权限修饰符的安全检查
		c.setAccessible(true);//暴力反射
		Object object = c.get(p);
		c.set(p, "李四");
		System.out.println(p.getC());

修改值之后：输出

field的所有代码：

package com.it.reflect;
import domain.Person;
import java.lang.reflect.Field;

public class ReflectDemo02 {
	//获取Person的Class对象
	
	
	public static void main(String[] args) throws Exception {
		
		//获取Person的Class对象
		Class<Person> personClass = Person.class;
		
		//获取成员变量 getFields()
		Field[] fields = personClass.getFields();
		
		for(Field field : fields) {
			System.out.println(field);
		}
		
		Field fi=personClass.getField("a");
		//获取成员变量a 的值
		Person p = new Person();
		Object reslut = fi.get(p);//get里面需要传入一个对象
		System.out.println(reslut);
		//设置a的值
		fi.set(p, "张三");
		
		System.out.println(p);
		System.out.println("============================");
		
		/**
		 * Field[] getDeclaredFields():获取所有的成员变量，不考虑修饰符，连私有的都可以获取
          Field getDeclaredField(String name)*
		 */
		Field[] declaredFields=personClass.getDeclaredFields();
		for(Field declaredField : declaredFields) {
				System.out.println(declaredField);
		}
		Field c	= personClass.getDeclaredField("c");
		//忽略访问权限修饰符的安全检查
		c.setAccessible(true);//暴力反射
		Object object = c.get(p);
		c.set(p, "李四");
		System.out.println(p.getC());
	}
	
	
}

2. 获取构造方法们
* Constructor<?>[] getConstructors()
* Constructor getConstructor(类<?>… parameterTypes)

• Constructor getDeclaredConstructor(类<?>… parameterTypes)
• Constructor<?>[] getDeclaredConstructors()

	public static void main(String[] args) throws Exception {
		
		//获取Person的Class对象
		Class<Person> personClass = Person.class;
		//Constructor<T> getConstructor(类<?>... parameterTypes)
		//获取的是构造方法，方法名和类名相同
		//构造方法的作用：创建对象 
		//有一个newInstance(Object...initargs)
		Constructor<Person> constructor = personClass.getConstructor(String.class,int.class);
		System.out.println(constructor);
		//创建对象，使用构造器创建对象
		Person person = constructor.newInstance("张三",21);//创建了张三 23岁这个对象
		System.out.println(person);		
	}
}

创建Person对象以及实例化的过程：
第一步：获取Class对象。
第二步：调用类对象的getConstructor方法，传入参数的类，返回一个构造器
第三步：我们就可以用这个构造器来创建对象构造器的方法newInstance

这里用的就是构造方法：
构造方法的名字必须与定义的类名完全相同，没有返回类型，甚至连void也没有。
构造方法的调用是在创建一个对象时使用new操作进行的。构造方法的作用是初始化对象 。
上代码：

public static void main(String[] args) throws Exception {
		
		//获取Person的Class对象
		Class<Person> personClass = Person.class;
		//Constructor<T> getConstructor(类<?>... parameterTypes)
		//获取的是构造方法，方法名和类名相同
		//构造方法的作用：创建对象 
		//有一个newInstance(Object...initargs)
		Constructor<Person> constructor = personClass.getConstructor(String.class,int.class);//返回一个构造器
		System.out.println(constructor);
		//创建对象，使用构造器创建对象
		Person person = constructor.newInstance("张三",21);//创建了张三 23岁这个对象
		System.out.println(person);
		
	}

打印结果：

由于Person里有两个方法：

如果使用空参数的构造方法来创建对象，

不简化的操作是：

//创建对象，使用构造器创建对象
		Person person = constructor.newInstance("张三",21);//创建了张三 23岁这个对象
		System.out.println(person);
		System.out.println("===========================");
		Constructor<Person> constructor2 = personClass.getConstructor();//返回一个构造器
		System.out.println(constructor2);
		//创建对象，使用构造器创建对象
		Person person2 = constructor2.newInstance();//
		System.out.println(person2);

打印结果：没有进行初始化

操作可以简化：使用Class对象的newInstance方法，直接就是空参

Object o = personClass.newInstance();
		System.out.println(o);

简化的代码就两行，就是直接调用类对象里的方法，而不是去获取构造器进行操作

3. 获取成员方法们：
Method[] getMethods()
Method getMethod(String name, 类<?>… parameterTypes)

Method[] getDeclaredMethods()
Method getDeclaredMethod(String name, 类<?>… parameterTypes)

无参函数

public static void main(String[] args) throws Exception {
	//获取Person的Class对象
			Class<Person> personClass = Person.class;
			
			//获取指定名称的方法
			//如何确定一个方法，方法名 加上 参数列表 ，因为没有参数，所以只有函数名称
			Method eat_method = personClass.getMethod("eat");
			//拿到方法，就执行它啊啊啊啊！！！执行
			Person p = new Person();//执行一个方法还是要创建对象的
			eat_method.invoke(p);				
	}

上面代码是调用无参方法，举一个有参函数的例子，里面有一个String类型的food：

代码实现：

public class ReflectDemo04 {
	
	public static void main(String[] args) throws Exception {
	//获取Person的Class对象
			Class<Person> personClass = Person.class;
			
			//获取指定名称的方法
			//如何确定一个方法，方法名 加上 参数列表 
			Method eat_method = personClass.getMethod("eat");
			//拿到方法，就执行它啊啊啊啊！！！执行
			Person p = new Person();//执行一个方法还是要创建对象的
			eat_method.invoke(p);
			
			Method eat_method2 = personClass.getMethod("eat",String.class);
			eat_method2.invoke(p, "饭");
			
	}
}

有参和无参的运行结果：

获取所有的public方法：

//获取所有的public修饰方法
			Method[] methods = personClass.getMethods();//得到一个数组
			for(Method method: methods) {//遍历
				System.out.println(method);
			}

注意：在person文件里，不仅仅有你看得见的方法，比如说eat.set,get方法，还有一些看不见的方法：

加上Declared的方法，可以扫描出所有类型的方法，不管是私有的方法，都可以使用method.setAccessible（true）的方式进行暴力反射。

method还有一个方法，可以返回方法名 getName()

package com.it.reflect;

import java.lang.reflect.Method;

import domain.Person;

/**
 *    3. 获取成员方法们：
             * Method[] getMethods()
             * Method getMethod(String name, 类<?>... parameterTypes)

             * Method[] getDeclaredMethods()
             * Method getDeclaredMethod(String name, 类<?>... parameterTypes)
             * 
             * 
 * @author 10953
 *
 */
public class ReflectDemo04 {
	
	public static void main(String[] args) throws Exception {
	//获取Person的Class对象
			Class<Person> personClass = Person.class;
			
			//获取指定名称的方法
			//如何确定一个方法，方法名 加上 参数列表 
			Method eat_method = personClass.getMethod("eat");
			//拿到方法，就执行它啊啊啊啊！！！执行
			Person p = new Person();//执行一个方法还是要创建对象的
			eat_method.invoke(p);
			
			Method eat_method2 = personClass.getMethod("eat",String.class);
			eat_method2.invoke(p, "饭");
			System.out.println("--------------------------------");
			//获取所有的public修饰方法
			Method[] methods = personClass.getMethods();//得到一个数组
			for(Method method: methods) {//遍历
				System.out.println(method);
				String name = method.getName();
				System.out.println(name);
			}
	}
}

执行：

4.获取类名

反射的案例

需求：写一个“框架”，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法
实现的方法：
1、配置文件
2、反射
步骤：
1.将需要创建的对象的全类名和需要执行的方法定义在配置文件中
2.在程序中加载读取配置文件
3.使用反射技术来加载类文件进内存
3.创建对象
4.执行方法

配置了全类名就应该想到这是反射机制
步骤：先创建properties配置文件，在配置文件里写上class的全限类名，还有类中的方法

反射实现代码：

package com.it.reflect;

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

/**
 * 假设的框架类
 * 
 * @author 10953
 *
 */
public class ReflectTest {

	public static void main(String[] args) throws Exception {

		// 前提：不能改变该类的任何方法，可以创建任意类的对象。可以执行任意方法
		// 1.加载配置文件
		Properties pro = new Properties();
		// 2.加载配置文件，转化为一个集合
		ClassLoader classLoader = ReflectTest.class.getClassLoader();// 获取类加载器
		InputStream is = classLoader.getResourceAsStream("pro.properties");// 使用类加载获取配置文件 pro.load(is);
		pro.load(is);
		//3.获取配置文件中定义的数据
		String className = pro.getProperty("className");
		String methodName = pro.getProperty("methodName");
		//4.加载该类进内存
		Class cls = Class.forName(className);//返回一个Class对象
		//5.创建对象,有了真得对象了
		Object obj = cls.newInstance();
		//6.获取方法对象
		Method method = cls.getMethod(methodName);
		//执行方法：
		method.invoke(obj);	
	}

}

步骤：
1、加载配置文件：就是new 一个properties，返回一个pro对象
得到对象之后，需要将配置文件读入数据，使用了io思想，然后这里使用类加载器
获得类加载器后，让资源变成流对象，进入内存。个人理解

ClassLoader classLoader = ReflectTest.class.getClassLoader();// 获取类加载器
InputStream is = classLoader.getResourceAsStream("pro.properties");// 使用类加载获取配置文件 pro.load(is);
pro.load(is);

2、可以通过pro对象获取文件中定义的数据（全类名和方法），使用方法：getProperty（）
3、上一步骤获取了类名。然后将类加载到内存，返回一个cls对象 Class.forname()
4、有了类之后就可以创建对象了，使用newInstance（）
5、执行方法
method.invoke()：用来执行某个对象的目标方法