反射机制

Java 作为静态语言，在编译的时候就已经确定了一个对象属于哪一个类。跟动态编程语言ruby ，python 或者Groovy 等都不同，虽然在运行效率上有很一定的优势，但是在当今对项目开发效率和开发进度要求极大的情况下，性能问题反倒显得不是至关重要。

Java 的反射（Reflection ）机制让我们在用Java 开发的时候有一定的动态性质，比方能在运行时才确定任意一个对象所属的类，构造任意一种对象，能够知道任意一个类所具有的成员和方法，并调用它的任意一个方法等。

起初Java 的反射机制效率比较低，是普通运行的十几倍，现在优化后已经进步很多，差不多是普通运行的一倍多。可以看出一方面动态带来的性能下降，另一方面，编译技术的进步能够让动态编程成为未来程序语言的主流。

但在这之前先总结下Java 的反射机制。

API 简介

Class 类：代表一个类。

Field 类：代表类的成员变量（成员变量也称为类的属性）。

Method 类：代表类的方法。

Constructor 类：代表类的构造方法。

Array 类：提供了动态创建数组，以及访问数组元素的静态方法。

Class 类的方法

getName() ：获得类的完整名字。

getFields() ：获得类的 public 类型的属性。

getDeclaredFields() ：获得类的所有属性。

getMethods() ：获得类的 public 类型的方法。

getDeclaredMethods() ：获得类的所有方法。

getMethod(String name, Class[] parameterTypes) ：获得类的特定方法，name 参数指定方法的名字，parameterTypes 参数指定方法的参数类型 。

getConstrutors() ：获得类的 public 类型的构造方法。

getConstrutor(Class[] parameterTypes) ：获得类的特定构造方法， parameterTypes 参数指定构造方法的参数类型。

newInstance() ：通过类的不带参数的构造方法创建这个类的一个对象。

获得一个类的所有方法

 

public class MethedNamesPrinter {
	
	public static void main(String[] args) throws ClassNotFoundException {
		Class classType = Class.forName("java.lang.String");
		Method[] methods = classType.getDeclaredMethods();
		for (Method method : methods) {
			System.out.println(method.toString());
		}
	}
	
}

 

得到一个指定的构造方法并生成实例

 

//这是一个被访问的类，只有4个构造方法
public class ConstructorTest {
	public ConstructorTest() {
		System.out.println("默认构造方法被调用");
	}
	public ConstructorTest(int arg_1) {
		System.out.println(arg_1 + "第二个构造方法被调用");
	}
	public ConstructorTest(int arg_2, String arg_3) {
		System.out.println(arg_2 + " " + arg_3 + "第三个构造方法被调用");
	}
	private ConstructorTest(String arg_4) {
		System.out.println(arg_4 + "第四个构造方法被调用，这是私有的");
	}
}
	//现在想办法让他们都被打印出来
	//首先打印第一个，默认的构造方法，代码如下
		Class classType = Class.forName("reflection.ConstructorTest");
		Constructor constructor = classType.getConstructor(null);
		constructor.newInstance(null); 
	//getConstructor的参数传null的话就表示没有参数类型，自然选择第一个构造方法
	//实例constructor在用newInstance()的时候自然不用传参，实例化结果正常打印出
	//！！！结果是：默认构造方法被调用

	//现在要访问第二个构造方法，参数是一个int类型，代码如下
		Class classType = Class.forName("reflection.ConstructorTest");
		Constructor constructor = classType
				.getConstructor(new Class[] { int.class });
		constructor.newInstance(10);
	//！！！结果是：10第二个构造方法被调用
	//实际上newInstance()只接受对象，“10”在编译过程自动被包装成Integer了。

	//访问第三个构造方法，参数列表不同了。如下代码
		Class classType = Class.forName("reflection.ConstructorTest");
		Constructor constructor = classType.getConstructor(new Class[] {
				int.class, String.class });
		constructor.newInstance(10, "我路过");
	//！！！结果是：10 我路过第三个构造方法被调用

	//访问第四个构造方法，注意啊，权限不同，这是重头戏来着。如下代码
		Class classType = Class.forName("reflection.ConstructorTest");
		Constructor constructor = classType
				.getDeclaredConstructor(new Class[] { String.class });
		constructor.setAccessible(true);
		constructor.newInstance(new String("我再路过"));
	//！！！结果是：我再路过第四个构造方法被调用，这是私有的
	//首先，不同的地方就是，这次是从所有构造方法中找到这个构造方法
//而之前用getConstructor()不包含私有的
//然后就是将这个构造器设置为可访问的，setAccessible(true)

 

得到一个指定的方法并调用

其实看了上面构造方法的，基本上也就知道方法应该怎么玩了。还是给出例子。

//这是被访问的类
public class MethodTest {
	public void print() {
		System.out.println("这是print()第一个方法");
	}
	public void print(int num) {
		System.out.println("这是print()第二个方法，有参数" + num);
	}
	public String print(String name) {
		System.out.println("这是print()第三个方法，有参数" + name);
		return name + "这个是返回的";
	}
	private void printPrivate() {
		System.out.println("这是print()第四个方法，是私有的");
	}
}

		//访问第一个方法，如下代码
		Class classtype = Class.forName("reflection.MethodTest");
		Method method = classtype.getDeclaredMethod("print", new Class[] {});
		Object object = classtype.newInstance();
		method.invoke(object, null); 
		//！！！结果是：这是print()第一个方法

		//访问第二个方法
		Class classtype = Class.forName("reflection.MethodTest");
		Method method = classtype.getDeclaredMethod("print",
				new Class[] { int.class });
		Object object = classtype.newInstance();
		method.invoke(object, 10);
		//！！！结果是：这是print()第二个方法，有参数10

		//访问第三个方法
		Class classtype = Class.forName("reflection.MethodTest");
		Method method = classtype.getDeclaredMethod("print",
				new Class[] { String.class });
		Object object = classtype.newInstance();
		System.out.println(method.invoke(object, "这是传进来的参数哦"));
		//！！！结果是：这是print()第三个方法，有参数这是传进来的参数哦
		//！！！结果是：这是传进来的参数哦这个是返回的

		//访问第四个方法
		Class classtype = Class.forName("reflection.MethodTest");
		Method method = classtype.getDeclaredMethod("printPrivate",
				new Class[] {});
		method.setAccessible(true);
		Object object = classtype.newInstance();
		method.invoke(object, null);
		//！！！结果是：这是print()第四个方法，是私有的

 

 

其他

好吧头痛死了，本来还想写点关于单例模式和反射机制的。以后写单例模式的时候顺带记录吧。