Java学习笔记--反射

什么是Java反射

概念

java反射是指java能够在运行时确定类的类型信息，包括其方法、字段、构造函数等，并能够通过反射调用类或者类对象的方法。在Java中，java.lang.Class类与java.lang.reflect类库一起对反射的概念进行了支持。

简单理解编译和运行

在运行一个java程序的时候，需要依次调用javac java命令来执行编译和运行。

对如下所示的程序

// OfficeCom.java
public interface OfficeCom {
	public void start();
}

// Word.java
public class Word implements OfficeCom {
	public void start() {
		System.out.println("Word!");
	}
}

// Excel.java
public class Excel implements OfficeCom {
	public void start() {
		System.out.println("Excel!");
	}
}

// Demo.java
public class Demo {
	public static void main (String[] args) {
		OfficeCom officeCom = null;
		if ("Word".equals(args[0])) {
			officeCom = new Word();
		} else if ("Excel".equals(args[0])) {
			officeCom = new Excel();
		}
		officeCom.start();
	}
}

执行编译命令javac Demo.java后，在目录下生成了Demo.class Word.class Excel.class OfficeCom.class文件，然后执行java Demo Word, 输出Word!

如果目录下缺少了Word.java文件后，执行javac Demo.java，编译错误，编译无法通过。

我们将Demo.java程序修改成反射获取类信息

// Demo.java
public class Demo {
	public static void main (String[] args) {
		try {
			Class c = Class.forName(args[0]);
			OfficeCom o = (OfficeCom)c.newInstance();
			o.start();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

然后执行javac Demo.java， 在目录下生成了Demo.class和OfficeCom.class，如果这个时候执行java Demo Word，会报错。对反射机制来说，.class文件在编译时是不可获取的，是在运行时打开和检查.class文件（注：java编程思想P335）。在执行javac Word.java后再执行java Demo Word，则正常输出Word!。注意到，这个时候，我们是否编写了Excel.java不会影响程序的编译和执行。如果后续需要更多的OfficeCom组件，只需要编写相应的java文件而不需要修改Demo.java。这也是动态加载类的一个优点。

Class类与类类型

Class类

在java中一切都是对象，通过一个类（Class），我们可以实例化一个对象（Object），同时这个类也是Class类的对象。

Instances of the class Class represent classes and interfaces in a running Java application. An enum is a kind of class and an annotation is a kind of interface. Every array also belongs to a class that is reflected as a Class object that is shared by all arrays with the same element type and number of dimensions. The primitive Java types (boolean, byte, char, short, int, long, float, and double), and the keyword void are also represented as Class objects.

通过查看Class类的源码, 只有JVM能够构造Class类对象

    /*
     * Private constructor. Only the Java Virtual Machine creates Class objects.
     * This constructor is not used and prevents the default constructor being
     * generated.
     */
    private Class(ClassLoader loader) {
        // Initialize final field for classLoader.  The initialization value of non-null
        // prevents future JIT optimizations from assuming this final field is null.
        classLoader = loader;
    }

获取类类型

我们通过一个已经创建的类获得的Class对象可以简单称为类类型（class type），获得类类型有三种方法。

//字面常量的方式，实际在告诉我们任何一个类都有一个隐含的静态成员变量class
Class c1 = Foo.class;

//第二中表达方式  已经知道该类的对象通过getClass方法
Class c2 = foo1.getClass();

//不管c1  or c2都代表了Foo类的类类型，一个类只可能是Class类的一个实例对象
System.out.println(c1 == c2);

//第三种表达方式
Class c3 = null;
try {
	c3 = Class.forName("com.imooc.reflect.Foo");
} catch (ClassNotFoundException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}
System.out.println(c2==c3);  // true

//我们完全可以通过类的类类型创建该类的对象实例
try {
	Foo foo = (Foo)c1.newInstance();//需要有无参数的构造方法
	foo.print();
} catch (InstantiationException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
} catch (IllegalAccessException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

上述还演示了通过类类型来实例化一个类对象的方法。

通过类类型我们还能获得更过关于这个类的信息。

反射方法的使用

Class c = obj.getClass();
// 获取类方法
Method[] methods = c.getMethods(); // 获取此类和其超类的public方法
Method[] methods = c.getDeclaredMethods(); // 获取此类的所有声明的方法，不包括继承的方法

// 获取构造函数
Constructor[] constructors = c.getConstructors(); // 获取此类的public构造方法
Constructor[] constructors = c.getDeclaredConstructors(); // 获取此类声明的所有构造方法
// 获取字段
Field[] fields = c.getFields(); // 获取此类的public字段
Field[] fields = c.getDeclaredFields(); // 获取所有此类声明的字段

获得到类的方法对象后，可以执行这个方法

public class Demo1 {

    public static void main(String[] args) {
        Foo foo = new Foo();
        Class c = foo.getClass();
        try {
            Method method = c.getMethod("print", int.class, int.class);
            method.invoke(foo, 10, 20); // invoke第一个参数是执行方法的对象
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}
class Foo {
    public void print(int a, int b) {
        System.out.println(a + b);
    }
    public void print(String a, String b) {
        System.out.println(a + b);
    }
}

同样可以获取构造函数生成一个实例

try {
         Constructor constructor = c.getDeclaredConstructor(String.class, int.class);
         constructor.setAccessible(true);  // 因为是私有的，所以需要声明可访问
         constructor.newInstance("hello", 5);
      } catch (NoSuchMethodException e) {
          e.printStackTrace();
      } catch (IllegalAccessException e) {
          e.printStackTrace();
      } catch (InstantiationException e) {
          e.printStackTrace();
      } catch (InvocationTargetException e) {
          e.printStackTrace();
      }

其他

Java编程思想中提到RTTI（Runtime Type Information），这个与反射有什么区别？参考知乎问题