Java反射机制

反射：框架设计的灵魂
框架：半成品软件。可以在框架的基础上进行软件开发，简化编码
反射：将类的各个组成部分封装为其他对象，这就是反射机制
好处：
1. 可以在程序运行过程中，操作这些对象。
2. 可以解耦，提高程序的可扩展性。

获取Class对象

1.Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象
多用于配置文件，将类名定义在配置文件中。读取文件，加载类
2.类名.class：通过类名的属性class获取
多用于参数的传递
3.对象.getClass()：getClass()方法在Object类中定义着。
多用于对象的获取字节码的方式
结论：
同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。

代码示例

package reflect;

import domain.Person;

public class ReflectTest1 {
	/**
	 * 获取Class对象的方式：
	 *   1.Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
	 *   2.类名.class：通过类名的属性class获取
	 *   3.对象.getClass()：getClass()方法在Object类中定义着
	 * 
	 */
	public static void main(String[] args) throws Exception {
		// 1.Class.forName("全类名")
		Class clasz1 = Class.forName("domain.Person");
		System.out.println(clasz1);
		
		// 2.类名.class
		Class clasz2 = Person.class;
		System.out.println(clasz2);
		
		//3.对象.getClass()
		Person p = new Person();
		Class clasz3 = p.getClass();
		System.out.println(clasz3);
		System.out.println(clasz1 == clasz2);//true
		
	}
}

Class对象功能

1. 获取成员变量

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

Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
Field getDeclaredField(String name)

//getFields()方法只能获取public成员变量
Class clasz = Person.class;
Field[] field = clasz.getFields();
for (Field field2 : field) {
	System.out.println(field2);
}
//getField(String name)获取指定名称的public成员变量
Field f = clasz.getField("a");
System.out.println(f);
//获取成员变量的值
Person p = new Person();
Object value = f.get(p);
System.out.println(value);
//设置成员变量的值
f.set(p, "张三");
System.out.println(p);
System.out.println("--------------------------");
//Field[] getDeclaredFields()获取所有的成员变量，不考虑修饰符
Field[] field3 = clasz.getDeclaredFields();
for (Field field2 : field3) {
	System.out.println(field2);
}	
//获取指定名称的成员变量
f = clasz.getDeclaredField("Name");
//忽略访问权限修饰符的安全检查
f.setAccessible(true);//暴力反射
System.out.println(f.get(p));

2. 获取构造方法

Constructor<?>[] getConstructors()

Constructor getConstructor(类<?>… parameterTypes)

Constructor getDeclaredConstructor(类<?>… parameterTypes)

Constructor<?>[] getDeclaredConstructors()

Class clasz = Person.class;
//Constructor<?>[] getConstructors() 
Constructor constructror = clasz.getConstructor(String.class,String.class);
System.out.println(constructror);
//使用newInstance创建对象
Object person = constructror.newInstance("张三","男");
System.out.println(person);
//空参构造可以使用Class的newInstance()方法
Object o = clasz.newInstance();
System.out.println(o);

3. 获取成员方法

Method[] getMethods()
Method getMethod(String name, 类<?>… parameterTypes)

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

Class clasz = Person.class;
Person p = new Person();
Method method = clasz.getMethod("Eat");
method.invoke(p);
method = clasz.getMethod("Eat",String.class);
method.invoke(p,"鸡腿");

4. 获取全类名

String getName()

Class clasz = Person.class;
System.out.println(clasz.getName());

Field：成员变量

操作：

1. 设置值
   void set(Object obj, Object value)

2. 获取值
   get(Object obj)

3. 忽略访问权限修饰符的安全检查
   setAccessible(true):暴力反射

Constructor:构造方法

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

Method：方法对象

• 执行方法：
  Object invoke(Object obj, Object… args)
  获取方法名称：
  String getName:获取方法名

案例

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

代码

1.配置文件

ClassName=domain.Person
MethodName=Eat

2.相关代码
Person类

package domain;

public class Person {
	public String a;
	protected String b;
	String c;
	private String Name;
	private String Sex;
	public String getName() {
		return Name;
	}
	public void setName(String name) {
		Name = name;
	}
	public String getSex() {
		return Sex;
	}
	public void setSex(String sex) {
		Sex = sex;
	}
	public Person(String name, String sex) {
		super();
		Name = name;
		Sex = sex;
	}
	public Person() {
		super();
	}
	@Override
	public String toString() {
		return "Person [a=" + a + ", b=" + b + ", c=" + c + ", Name=" + Name + ", Sex=" + Sex + "]";
	}
	public void Eat() {
		System.out.println("eat...");
	}
	public void Eat(String food) {
		System.out.println("eat..."+food);
	}
}

Student类

package domain;

public class Student {
	public void Sleep() {
		System.out.println("Sleep...");
	}
}

3.实现代码

package reflect;

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

public class Reflec {
	public static void main(String[] args) throws Exception {
		Properties p = new Properties();
		InputStream in = Reflec.class.getClassLoader().getResourceAsStream("pro.properties");
		p.load(in);
		String ClassName = p.getProperty("ClassName");
		String MethodName = p.getProperty("MethodName");
		//加载进内存
		Class clasz = Class.forName(ClassName);
		//获取对象
		Object obj = clasz.newInstance();
		//获取方法对象
		Method method = clasz.getMethod(MethodName);
		method.invoke(obj);
	}	
}