Java之反射

什么是反射？

（1）Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。 本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。

（2）Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了， 而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到， 所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性， 不需要提前在编译期知道运行的对象是谁。

简单说就是能够分析类信息的能力的程序叫做反射（类信息指的就是比如属性、方法、构造器等）

举一个实际的例子，在servlet框架当中我们写过JBDC类，在这个类当中我们引入了一个mysql.jar包，那么这个jar包是怎么起作用的呢，而servlet类当中没有main方法，让servlet类启动，加载到JVM当中就用到了反射

反射是如何工作的，要想理解反射是如何工作的先了解下类的生命周期

 

 反射的好处 ： 

1.在程序的运行过程中，来操作这些对象

2.可以解耦，提高程序的可扩转性

获取class对象的方式

 1.Class.forName("全类名")：将字节码文件加载进内存，返回class对象(多用于配置文件，将类名定义在配置文件当中，读取文件，加载类)

2.类名.class:通过类名的class获取 （多用于参数传递）

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

上代码

首先定义一个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对象都是同一个

class对象功能

获取成员变量

1.Field[] getFields() ：获取所有public修饰的成员变量

2.Field getField(String name)：获取指定名称的

3.Field[] getDeclaredFilds()：获取所有的成员变量，不考虑修饰符

4.Field getDeclaredField(String name)

获取构造方法

1.Constructor[] getConstructors()

2.Constructor getConstructor(类...parameterTypes)

3.Constructor[] getDeclaredConstructors()

4.Constructor getDeclaredConstructors(类...parameterTypes)

获取方法名

1.Method[] getMethod()

2.Method getMethod(String name,类... parameterTypes)

3.Method[] getDeclaredMethod()

4.Method getDeclaredMethod(String name,类... parameterTypes)

获取类名

String getName()

Field成员变量

1.设置值

      void set(Object obj,Object value)

2.获取值

     get(Object obj)

3.忽略安全访问修饰符的安全检查

     setAccessible(true)       //暴力反射 ---》private

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

        //0.获取Person的Class对象
        Class personClass = Person.class;
        /*
             1. 获取成员变量们
                 * Field[] getFields()
                 * Field getField(String name)

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

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

        System.out.println("------------");
        //2.Field getField(String name)
        Field a = personClass.getField("a");
        //获取成员变量a 的值
        Person p = new Person();
        Object value = a.get(p);
        System.out.println(value);
        //设置a的值
        a.set(p,"张三");
        System.out.println(p);

        System.out.println("===================");

        //Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        //Field getDeclaredField(String name)
        Field d = personClass.getDeclaredField("d");
        //忽略访问权限修饰符的安全检查
        d.setAccessible(true);//暴力反射
        Object value2 = d.get(p);
        System.out.println(value2);

    }

Constructor访问构造方法

创建对象

T newInstance(Object... initarges)

如果使用空参数构造方法，此操作可以简化：class对象的newInstance方法

public static void main(String[] args) throws Exception {
		//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);
		
		System.out.println("-------------------------------");
	
		Constructor constructor1 = personClass.getConstructor();
		System.out.println(constructor1);
		//创建对象
		Object perObject1 = constructor1.newInstance();
		System.out.println(perObject1);
		
		System.out.println("-------------------------------");
		Object o = personClass.newInstance();
		System.out.println(o);
	}

Method:方法对象

执行方法

object invoke(Object object,Object... ages)

获取方法名称

String getName:获取方法名

public static void main(String[] args) throws Exception {
		//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);
		}
	}