参考资料：
Rollen Holt的博客： http://www.cnblogs.com/rollenholt/archive/2011/09/02/2163758.html
C'est la vie的博客： http://www.cnblogs.com/jqyp/archive/2012/03/29/2423112.html
coolszy的博客： http://coolszy.iteye.com/blog/569846
leeon的博客： http://www.cnblogs.com/octobershiner/archive/2012/03/18/2404751.html
感谢上面4位博主
一、什么是反射机制
简单的来说，反射机制指的是程序在运行时能够获取自身的信息。
在java中，只要给定类的名字，那么就可以通过反射机制来获得类的所有信息。
二、哪里用到反射机制
有些时候，我们用过一些知识，但是并不知道它的专业术语是什么，jdbc用过一行码,Class.forName("com.mysql.jdbc.Driver.class").newInstance();但是那时候只知道那行代码是生成 驱动对象实例，并不知道它的具体含义。听了反射机制这节课后，才知道，原来这就是反射，现在很多开框架都用到反射机制，hibernate、struts都是用反射机制实现的。
三、反射机制的优点与缺点
为什么要用反射机制？直接创建对象不就可以了吗，这就涉及到了动态与静态的概念，
静态编译：在编译时确定类型，绑定对象,即通过。
动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了java的灵活性，体现了多 态的应用，有以降低类之间的耦合性。一句话，反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中它的灵活性就表现的十分明显。比如，一个大型的软件，不可能一次就把把它设计的很完美，当这个程序编译后，发布了，当发现需要更新某些功能时，我们不可能要用户把以前的卸载，再重新安装新的版本，假如这样的话，这个软件肯定是没有多少人用的。采用静态的话，需要把整个程序重新编译一次才可以实现功能的更新，而采用反射机制的话，它就可以不用卸载，只需要在运行时才动态的创建和编译，就可以实现该功能。
它的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。
四、利用反射机制能获得什么信息
类中有什么信息，它就可以获得什么信息，不过前提是得知道类的名字，要不就没有后文了
首先得根据传入的类的全名来创建Class对象。
Class c=Class.forName("className"); 注：className必须为全名，也就是得包含包名，比如，cn.netjava.pojo.UserInfo;
Object obj=c.newInstance(); //创建对象的实例
OK，有了对象就什么都好办了，想要什么信息就有什么信息了。
获取类型信息
在没有对象实例的时候，主要有三种办法。
//获得类类型的三种方式
Class classtype1 = Class.forName("com.evor.test.Person"); Class classtype2 = new Person().getClass(); Class classtype2 = Person.class;
第一种方式中，forName中的参数一定是完整的类名（包名+类名），并且这个方法需要捕获异常。
4.1 获得构造器的方法
首先介绍一下Constructor类，这个类用来封装反射得到的构造器，Class有四个方法来获得Constructor对象
| Constructor getConstructor(Class[] params) | 根据指定参数获得public构造器 |
| Constructor[] getConstructors() | 获得public的所有构造器，类中第一个构造器下标为0 |
| Constructor getDeclaredConstructor(Class[] params) | 根据指定参数获得public和非public的构造器 |
| Constructor[] getDeclaredConstructors() | 获得public的所有构造器 |
从名字来看，还是很好懂的，带上Declared的都是获得所有的构造方法，包括私有。
列举上面几种方法如何使用
1.
//指定参数列表获取特定方法，此处没参数，为默认构造方法 Constructor<?> constr1 =classtype1.getDeclaredConstructor();
Object obj1 = constr1.newInstance(new Object[]{});//使用构造器创建实例
2.
//指定参数列表获取特定方法 Constructor<?> constr2 = classtype2.getDeclaredConstructor(new Class[]{String.class,String.class,String.class,int.class}); //输出构造器名 System.out.println(constr2); //使用构造器创建实例 Object obj2 = constr2.newInstance(new Object[]{"20000001","李明","男",19}); //创建一个实例
3.
//获取所有的构造方法集合 Constructor<?> constr3[] =classtype1.getDeclaredConstructors(); //使用构造器创建实例 Object obj3 = constr3[1].newInstance(new Object[]{"30000001","张三","男",27});
4.2 获得类方法的方法
| Method getMethod(String name, Class[] params) | 根据方法名，参数类型获得方法 |
| Method[] getMethods() | 获得所有的public方法 |
| Method getDeclaredMethod(String name, Class[] params) | 根据方法名和参数类型，获得public和非public的方法 |
| Method[] getDeclaredMethods() | 获得所以的public和非public方法 |
Method method = classtype1.getMethod("getInfo");//获取getInfo()方法
Object infoobj1 = method.invoke(obj1); //使用方法，获取人的信息
System.out.println((String)infoobj1); //输出返回值
4.3 获得类中属性的方法
| Field getField(String name) | 根据变量名得到相应的public变量 |
| Field[] getFields() | 获得类中所以public的方法 |
| Field getDeclaredField(String name) | 根据方法名获得public和非public变量 |
| Field[] getDeclaredFields() | 获得类中所有的public和非public方法 |
Field fields[] = classtype1.getDeclaredFields(); //part1 获取类的所有属性 for(int i = 0 ; i <3 ; i ++){ fields[i].setAccessible(true); System.out.print((String)fields[i].get(obj2)+" "); } Field fieldsno = classtype1.getDeclaredField("age");//part2 获取年龄属性 fieldsno.setAccessible(true);//不设置可能发生异常 int s1_age =(int)fieldsno.get(obj2); System.out.println(s1_age);
输出结果：20000001 李明 男 19
实例：
public class Test1{
public static void main(String args[]){
Class<?> classtype1 = null; //类类型
Class<?> classtype2=null;
Class<?> classtype3=null;
try{
classtype1=Class.forName("com.evor.test.Person"); //获得类类型
}catch(Exception e){
}
classtype2 = new Person().getClass(); //另一种获得类类型的方式
classtype3 = Person.class; //另一种获得类类型的方式
System.out.println("类名称"+classtype1.getName());
System.out.println("类名称"+classtype2.getName());
System.out.println("类名称"+classtype3.getName());
System.out.println("三种类实质上类型是一样的，只是获得类型方式不同");
try {
//获取构造器
Constructor<?> constr1 =classtype1.getDeclaredConstructor();
Constructor<?> constr2 = classtype2.getDeclaredConstructor(new Class[]{String.class,String.class,String.class,int.class});
//输出构造器名
Constructor<?> constr3[] =classtype1.getDeclaredConstructors();
constr3[1].newInstance(new Object[]{"30000001","张三","男",27});
constr1.setAccessible(true);//设置可访问的权限
System.out.println("构造器1："+constr1);
System.out.println("构造器2："+constr2);
System.out.println("构造器组："+constr3);
//使用构造器创建实例
Object obj1 = constr1.newInstance(new Object[]{});
Object obj2 = constr2.newInstance(new Object[]{"20000001","李明","男",19}); //创建一个实例
System.out.println("对象1："+obj1);
System.out.println("对象2："+obj2);
//获取类的方法，并使用
System.out.println("========获取方法并使用========");
Method method = classtype1.getMethod("getInfo");//获取getInfo()方法
Object infoobj1 = method.invoke(obj1); //使用方法，获取人的信息
Object infoobj2 = method.invoke(obj2); //使用方法
System.out.println((String)infoobj1); //输出返回值
System.out.println((String)infoobj2);
//获取类的属性，并使用
System.out.println("========获取属性========");
Field fields[] = classtype1.getDeclaredFields();//获取类的所有属性
for(int i = 0 ; i <3 ; i ++){
fields[i].setAccessible(true);
System.out.print((String)fields[i].get(obj2)+" ");
}
Field fieldsno = classtype1.getDeclaredField("age");//获取年龄属性
fieldsno.setAccessible(true);//不设置可能发生异常
int s1_age =(int)fieldsno.get(obj2);
System.out.println(s1_age);
} catch (Exception e) {
e.printStackTrace();
}
/*
System.out.println("================");
Method[] method = classtype1.getMethods(); //获取类的方法
for(int i=0;i<method.length;++i){
Class<?> returnType = method[i].getReturnType(); //获取方法的返回值类型
Class<?> para[] = method[i].getParameterTypes(); //获取方法的参数类型表
int temp = method[i].getModifiers();
System.out.print(Modifier.toString(temp)+" ");
System.out.print(returnType.getName()+ " ");
System.out.print(method[i].getName()+" ");
System.out.print("(");
for(int j = 0 ; j <para.length ; j++){
System.out.print(para[j].getName()+" "+"arg"+j);
if(j<para.length-1){
System.out.print(",");
}
}
Class<?> exce[]=method[i].getExceptionTypes();
if(exce.length>0){
System.out.print(") throws ");
for(int k=0;k<exce.length;++k){
System.out.print(exce[k].getName()+" ");
if(k<exce.length-1){
System.out.print(",");
}
}
}else{
System.out.print(")");
}
System.out.println();
}*/
}
}
class Person{
private String sno ;
private String sname ;
private String sex ;
private int age;
public Person(){
this.sno = "unknow";
this.sname = "unknow";
this.sex = "unknow";
this.age = 0;
}
public Person(String sno, String sname , String sex , int age){
this.sno = sno;
this.sname = sname;
this.sex = sex;
this.age = age;
}
public void setSno(String sno){
this.sno = sno;
}
public void setSname(String sname){
this.sname = sname;
}
public void setSex(String sex){
this.sex = sex;
}
public void setAge(int age){
this.age = age;
}
public String getSno() {
return sno;
}
public String getSname() {
return sname;
}
public String getSex() {
return sex;
}
public int getAge() {
return age;
}
public String getInfo(){
return "学号："+sno+"，姓名："+sname+"，性别："+sex+"，年龄:"+String.valueOf(age);
}
}
输出
类名称com.evor.test.Person
类名称com.evor.test.Person
类名称com.evor.test.Person
三种类实质上类型是一样的，只是获得类型方式不同
构造器1：public com.evor.test.Person()
构造器2：public com.evor.test.Person(java.lang.String,java.lang.String,java.lang.String,int)
构造器组：[Ljava.lang.reflect.Constructor;@1db9742
对象1：com.evor.test.Person@106d69c
对象2：com.evor.test.Person@52e922
========获取方法并使用========
学号：unknow，姓名：unknow，性别：unknow，年龄:0
学号：20000001，姓名：李明，性别：男，年龄:19
========获取属性========
20000001 李明 男 19