Java 反射学习笔记

2019-03-24

这篇文章主要介绍的是 Java 反射，包含反射的基本知识，对反射原理不了解的可以瞄一眼。

1.Class 类的使用

1.1 任何一个类都是 Class 类的实例对象

注意大小写！我们平时写的类都是普通的 class 类，而普通的类其实都是 Class 类的实例。举个例子，比如在正常情况下我们获取一个类的实例的方式为：

1	Fruit banana = new Fruit();

那么就可以理解为：banana 是 Fruit 类的实例对象，而 Fruit 类是 Class 类的实例对象。

1.2 获取Class类的三种方式

第一种方式：

1	Class c1 = Fruit.class;

第二种方式：

1	Class c2 = banana.getClass();

第三种方式：

Class c3 = null;
try {
    c3 = Class.forName(“com.demo.Fruit”);//写完整的类名
} catch(ClassNotFoundException e) {
    e.printStackTrace();
}

一个类只可能是 Class 类的一个实例对象，因此 c1 == c2、c2 == c3 都为 true。

通过 Class 类来创建某个类的实例的方式为：（对于 Class.forName() 这种方式，它会把字符串所代表的类 load 到内存，但不会创建类的实例，没有实例的话程序无法运行）

try {
    Fruit apple = (Fruit)c1.newInstance();//需要强转，且 Fruit 类要有无参的构造方法。
    apple.eat();

} catch (InstantiationException e) {
    e.printStackTrace();
}

1.3 Class 动态加载类

首先我们要明白静态加载和动态加载的区别。

静态加载：编译时加载类
动态加载：运行时加载类

辅助性的功能尽量使用动态加载，例如QQ的在线升级，在原有的代码不需要重新编译的情况下就能增加新功能。

静态加载 Demo：

class StaticLoad
{
	public static void main(String[] args) 
	{
		if ("apple".equals(args[0]))
		{
			Apple apple = new Apple();
			apple.eat();
			System.out.println("eat apple ...... !");
		}
		if ("banana".equals(args[0]))
		{
			Banana banana = new Banana();
			banana.eat();
			System.out.println("eat banana ...... !");
		}
	}
}

interface Fruit
{
	public void eat();
}

class Apple implements Fruit
{
	public void eat()
	{
		System.out.println("eat apple ...... !");
	}
}

用 new 创建对象是静态加载，编译时就会加载所有可能会用到的类，因为没有 Banana 类，所以上面的例子即使在用不到 Banana 类的情况下，编译时也会报错。

动态加载 Demo：

class DynamicLoad
{
	public static void main(String[] args) 
	{
		try
		{
			Class ca = Class.forName(args[0]);
			Fruit fruit = (Fruit)ca.newInstance();
			fruit.eat();
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
		
	}
}

1	$ java DynamicLoad Apple（用反射后传什么类就运行什么类）

以后别人在添加 Banana 类时，实现 Fruit 接口然后单独编译即可，不需要对以前的代码重新编译。

2.反射中常用的方法

Class ca = obj.getClass();
// 获取所有的public的方法，包括从父类继承来的方法
Method[] methods_all = ca.getMethods();
// 获取所有自己声明的方法，不包括从父类继承来的方法
Method[] methods_declare = ca.getDeclaredMethods();
// 获取类属性，跟获取类方法类似
Method[] fields_all = ca.getFields();
Method[] fields_declare = ca.getDeclaredFields();

3.通过反射调用具体方法

public class MethodDemo1 
{
	public static void main(String[] args) 
	{
		A a1 = new A();
		Class ca = a1.getClass();
		try
		{
			// 获取方法对象
			//Method m = ca.getMethod("print", new Class[]{int.class, int.class});

			// 跟上一行注释的代码是一个意思
			Method m = ca.getMethod("print", int.class, int.class); 
			// 通过反射调用具体方法（重点）
			m.invoke(a1, new Object[]{10, 20});

			System.out.println("---------------------------------------");
			Method m2 = ca.getMethod("print");
			//m2.invoke(a1, new Object[]{});// 没有参数就不传
			m2.invoke(a1);//跟上一行注释的代码是一个意思
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
	}
}


class A
{
	public void print()
	{
		System.out.println("没有参数就不传");
	}
	public void print(int a, int b)
	{
		System.out.println(a + b);
	}
	public void print(String a, String b)
	{
		System.out.println(a.toUpperCase() + "," + b.toLowerCase());
	}
}

有时我们可能会看到有些方法的参数中带有三个点，这表示该参数的个数不固定，我们在调用这个方法传参的时候，有多少个参数就传多少个参数。

4.通过 Class 和 Method 认识泛型的本质

public class MethodDemo4
{
	public static void main(String[] args) 
	{
		ArrayList list = new ArrayList();
		ArrayList<String> list_fan = new ArrayList<String>();
		list_fan.add("hello");

		Class ca = list.getClass();
		Class ca_fan = list_fan.getClass();
		System.out.println(ca == ca_fan);

		/*
		ca == ca_fan 结果返回 true 说明编译之后的集合的泛型
		是去泛型化的，由此可见，Java 中集合的泛型防止错误
		输入只在编译阶段有效，绕过编译就无效了。（重点）
		原因是在编译之后对泛型进行了类型擦除。

		验证：通过反射来实现添加元素操作，绕过编译。
		*/
		try
		{
			Method m = ca_fan.getMethod("add", Object.class);
			m.invoke(list_fan, 20);// 绕过编译操作就绕过了泛型
			System.out.println(list_fan.size());
			System.out.println(list_fan);
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
	}
}

（完）