Java反射机制

Java反射机制

前言

首先向自己道个歉，自从上一篇文章说要以写教案的形式提高自己以来，迟迟未动手，一方面，是因为这段时间一直在准备专八考试和毕业论文，实在是有点力不从心；另一方面，是自己尚未充分的构思好要如何切入反射这个重要的知识点。现在终于有时间可以动手了，言归正传。

还是从头开始说比较好。

首先，本文的线索是：

• 什么是反射
• 类的加载机制
• javalang.Class类
• 反射的应用

1、什么是反射？

• Java反射机制其实是动态的获取信息以及动态调用对象的功能；

• 而所谓动态是指，对于任意一个运行状态的类，都能够知道这个类的所有属性和方法

• 并且对于任意一个对象，都能调用他任意一个方法

而要搞清楚什么是运行状态，必须要搞清楚的是一个类的加载机制

2、类的加载机制

2.1、类的加载

一个类在内存中的生命周期：加载——使用——卸载

2.2、类的加载过程

类的加载分为三步（加载—连接—初始化），这三个步骤统称为类加载，当一个程序在使用某个类的时候，系统就会加载、连接、初始化这三个步骤，完成对这个类的加载：

• 加载：将类的class字节码数据读入到内存中
• 连接：
  • ①验证：（如果是非字节码文件，校验不能通过，就好比.class文件里面写的是中文）、
  • ②准备：通过校验之后会在方法区分配内存，并且创建Class对象，为类的编码赋初始值
  • ③解析：把字节码中的符号引用替换成对应的直接引用的地址
• 初始化：执行类的初始化方法

2.2.1、类加载器ClassLoader

我一开始一直没有搞懂的一个问题就是，类时怎么加载的，所以我查看了《Java核心技术卷》，才知道类的加载还分为几个类型：

• 类加载器（也称为根类加载器）：负责加载核心类库（lib.jar和rt.jar）
• 扩展类加载器：负责加载从核心类库拓展而来的类
• 应用类加载器：负责加载项目路径下的类
• 自定义加载器：
  • 当程序中需要加载特定目录下的类时，可以自定义类加载器
  • tomcat中也会遇到

2.2.2、类的初始化

我们都知道一下情况下会导致类的初始化：

• 运行主方法所在的类时，要先完成类的初始化，然后再执行mian方法
• 使用new创建对象时，如果这个类没有初始化，会先完成初始化再创建实例化对象
• 调用类的静态成员时，如果这个类没有初始化，也会先初始化类
• 当子类在初始化时，发现父类还未初始化，那么也将初始化父类

除了以上四种情况外，还有一种情况：

当我们通过反射来使用某个类的时候，如果该类为被初始化，也会导致类初始化

这里咱们留一个问题，什么情况下，使用类的操作不会导致类被初始化呢？

3、Class对象——类的反射根源

java.lang.Class和java.lang.reflect.*是分析类与解决反射问题的API，而总共有四种可以获取Class对象的方法

• 类型名.Class

  String.Class;//这时要求这个类为编译期间已知的类型
  

• 对象.getClass()

  class Person{
      private String name;
      private int age;
  }
  
  public class Test{
      public static void main(String[] args){
          Person p = new Person();
          p.getClass();//获取对象运行时的类，需要注意的是，我们前面的分析重要性
      }
  }
  

• Class.forName(类型的全名称)：可以获取到编译期间未知的类型

• ClassLoader的类加载器对象.loadClass(类型全名称)：这种方式有好像是不不推荐的，或者说是使用的比较少

4、反射的应用

前面我们说过了，反射可以在一个类的所有信息并使用，类的信息无非就是类变量和类成员方法（以及构造方法）

4.1、通过反射调用构造方法并使用

4.1.1、通过反射调用无参构造方法并使用

class Person{
     private String name;
     private int number;
}

public class ReflectTest {
	public static void main(String[] args) throws Exception {
		// 获取字节码文件对象
		Class c = Person.class;
		// 获取构造方法
		public Constructor[] getConstructors():// 获取所有公共构造方法
		public Constructor[] getDeclaredConstructors():// 所有构造方法包括私有的
		Constructor[] cons = c.getDeclaredConstructors();
		for (Constructor con : cons) {//增强for循环遍历输出构造方法
			System.out.println(con);
		}

		// 获取单个构造方法
		public Constructor<T> getConstructor(Class<?>... parameterTypes)
		// 参数表示的是：你要获取的构造方法的构造参数个数及数据类型的class字节码文件对象
		Constructor con = c.getConstructor();// 返回的是构造方法对象

		Person p = new Person();
		System.out.println(p);
		public T newInstance(Object... initargs)
		// 使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
		Object obj = con.newInstance();//newInstance创建对象是这个类必须已经加载过且已经连接
		System.out.println(obj);
		
		Person p = (Person)obj;
		p.show();
	}
}

4.1.2、通过反射调用有参构造方法并使用

public class ReflectTets01 {
	public static void main(String[] args) throws Exception {
		// 获取字节码文件对象
		Class c = Person.class;

		// 获取带参构造方法对象
		// public Constructor<T> getConstructor(Class<?>... parameterTypes)
		Constructor con = c.getConstructor(String.class, int.class,
				String.class);

		// 通过带参构造方法对象创建对象
		// public T newInstance(Object... initargs)
		Object obj = con.newInstance("Django", 21, "四川");
		
		System.out.println(obj);
	}
}

4.1.3、通过反射获取成员变量并使用

public class ReflectDemo {
	public static void main(String[] args) throws Exception {
		// 获取字节码文件对象
		Class c = Person.class;

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

		/*
		 * Person p = new Person(); p.address = "北京"; System.out.println(p);
		 */

		// 通过无参构造方法创建对象
		Constructor con = c.getConstructor();
		Object obj = con.newInstance();
		System.out.println(obj);

		// 获取单个的成员变量
		// 获取address并对其赋值
		Field addressField = c.getField("address");
		// public void set(Object obj,Object value)
		// 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
		addressField.set(obj, "北京"); // 给obj对象的addressField字段设置值为"北京"
		System.out.println(obj);

		// 获取name并对其赋值
		// NoSuchFieldException
		Field nameField = c.getDeclaredField("name");
		// IllegalAccessException
		nameField.setAccessible(true);
		nameField.set(obj, "hhh");
		System.out.println(obj);

		// 获取age并对其赋值
		Field ageField = c.getDeclaredField("age");
		ageField.setAccessible(true);
		ageField.set(obj, 27);
		System.out.println(obj);
	}
}

4.1.4、通过反射获取成员方法并使用

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

public class ReflectDemo {
	public static void main(String[] args) throws Exception {
		// 获取字节码文件对象
		Class c = Person.class;

		// 获取所有的方法
		Method[] methods = c.getMethods(); // 获取自己的包括父类的公共方法
		Method[] methods = c.getDeclaredMethods(); // 获取自己的所有的方法
		for (Method method : methods) {
			System.out.println(method);
		}

		Constructor con = c.getConstructor();
		Object obj = con.newInstance();

		/*
		 * Person p = new Person(); p.show();
		 */

		// 获取单个方法并使用
		// public void show()
		// public Method getMethod(String name,Class<?>... parameterTypes)
		// 第一个参数表示的方法名，第二个参数表示的是方法的参数的class类型
		Method m1 = c.getMethod("show");
		// obj.m1(); // 错误
		// public Object invoke(Object obj,Object... args)
		// 返回值是Object接收,第一个参数表示对象是谁，第二参数表示调用该方法的实际参数
		m1.invoke(obj); // 调用obj对象的m1方法

		System.out.println("----------");
		// public void method(String s)
		Method m2 = c.getMethod("method", String.class);
		m2.invoke(obj, "hello");
		System.out.println("----------");

		// public String getString(String s, int i)
		Method m3 = c.getMethod("getString", String.class, int.class);
		Object objString = m3.invoke(obj, "hello", 100);
		System.out.println(objString);
		// String s = (String)m3.invoke(obj, "hello",100);
		// System.out.println(s);
		System.out.println("----------");

		// private void function()
		Method m4 = c.getDeclaredMethod("function");
		m4.setAccessible(true);
		m4.invoke(obj);
	}
}

犹如囫囵吞枣，不知道说了个啥，写完后我只感觉一头乱麻，希望下次不要这样

天高任鸟飞，水深凭鱼跃！