java反射机制小结

java的反射机制一直是java的一块重要内容，掌握它对日后的框架学习会有很大的帮助。 

我们先来看看什么是反射机制。反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过采用某种机制来实现对自己行为的描述（self-representation）和监测（examination），并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。

那么Java反射有什么作用呢？

假如我们有两个程序员，一个程序员在写程序的时候，需要使用第二个程序员所写的类，但第二个程序员并没完成他所写的类。那么第一个程序员的代码能否通过编译呢？这

是不能通过编译的。利用Java反射的机制，就可以让第一个程序员在没有得到第二个程序员所写的类的时候，来完成自身代码的编译。

Java的反射机制它知道类的基本结构，这种对Java类结构探知的能力，我们称为Java类的“自审”。大家都用

过Jcreator和eclipse。当我们构建出一个对象的时候，去调用该对象的方法和属性的时候。一按点，编译工具

就会自动的把该对象能够使用的所有的方法和属性全部都列出来，供用户进行选择。这就是利用了Java反射的

原理，是对我们创建对象的探知、自审。

java的反射机制就是增加程序的灵活性，避免将程序写死到代码里，

例如： 实例化一个 person()对象， 不使用反射，new person(); 如果想变成 实例化 其他类， 那么必须修改源代码，并重新编译。

使用反射：class.forName("person").newInstance()； 而且这个类描述可以写到配置文件中，如 **.xml, 这样如果想实例化其他类，只要修改配置文件的"类描述"就可以了，不

需要重新修改代码并编译。

由上述内容可知，很多时候反射并非一定要用，但框架对灵活性要求较高，所以反射在框架中使用较多。

最后我给出反射的一些简单使用方法。

先在cla包下定义一个类Foo，我要获得该类的类类型(class type)。哦，这里要补充一下，在面向对象的世界里，万物

皆对象。类也是一种对象，它是java.lang.Class类的对象。Class类只能由虚拟机创建。

有以下三种方法获得该类的类类型：

第一种：Class class1 = Foo.class;

第二种：Class class2 = foo1.getClass();  //其中foo1是Foo的一个实例对象

第三种：

Class class3 = null;
try {
class3 = Class.forName("cla.Foo");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

有了类类型，我们就有了该类编译后的信息。同一个类编译后只产生一个实例。所以class1 == class2 == class3

当然，class类还有很多方法。如getName()(包名+类名)。getMethods()获得所有能在类外部访问到的方法。getDeclaredMethods()获得所有声明的方法。类似的还有

getFields()，getDeclaredFields()获得成员变量信息。getConstructors()，getDeclaredConstructors()获得构造函数信息等等。

直接贴个示例代码：

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


public class ClassUtil {

	public static void printClassMethod(Object object) {
		Class class1 = object.getClass();
		System.out.println("类的名称是：" + class1.getName());
		
		//包括父类继承来的方法
		Method[] methods = class1.getMethods();
		//不包括父类继承的方法
//		Method[] methods = class1.getDeclaredMethods();
		
		for(Method method : methods) {
			System.out.print(method.getReturnType() + " ");
			System.out.print(method.getName() + "(");
			
			Class[] paramTypes = method.getParameterTypes();
			for(Class param : paramTypes) {
				System.out.print(param.getName() + " ");
			}
			System.out.println(")");
		}
		
	}
	private static void getClassField(Object object) {
		Class class1 = object.getClass();
		Field[] fs = class1.getFields();
//		Field[] fs = class1.getDeclaredFields();
		for(Field fd : fs) {
			Class fieldType = fd.getType();
			String typeName = fieldType.getName();
			//获得成员变量的名称
			String fieldName = fd.getName();
			System.out.println(typeName + " " + fieldName);
		}
	}
	
	public static void printConMessage(Object object) {
		Class class1 = object.getClass();
//		Constructor[] constructors = class1.getConstructors();
		Constructor[] constructors = class1.getDeclaredConstructors();
		
		for(Constructor constructor : constructors) {
			System.out.print(constructor.getName() + "(");
			
			Class[] paramTypes = constructor.getParameterTypes();
			for(Class param : paramTypes) {
				System.out.print(param.getName() + " ");
			}
			System.out.println(")");
		}
		
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Father father = new Father();
		Son son = new Son(1, "gg", 9.9);
		
		printClassMethod(father);
		System.out.println();
		printClassMethod(son);
		
		/*getClassField(father);
		System.out.println();
		getClassField(son);*/
		
		/*printConMessage(father);
		System.out.println();
		printConMessage(son);*/
	}

}

说到这我举个反射应用的小栗子：

最后贴一个调用方法的栗子：

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;


public class MethodDemo1 {

	public static void main(String[] args) 
throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		// TODO Auto-generated method stub
		A a = new A();
		Class class1 = a.getClass();
		/**
		 * getMethod方法最后一个参数是可变参数 这里亦可写为("print",  int.class, int.class);
		 */
		Method method = class1.getMethod("print",  new Class[]{int.class, int.class});
		method.invoke(a, 10,20);
		
		method = class1.getDeclaredMethod("print",  String.class,String.class);
		method.invoke(a, "HHgg", "hhHH");
	}

}

class A {
	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());
	}
}

通过反射我们还可以验证java的伪泛型，只要绕过编译，集合的泛型都是去泛型化的。