JAVA的反射机制

什么是反射机制

百度百科上的定义是这么说的，

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

JAVA反射（放射）机制：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。但是JAVA有着一个非常突出的动态相关机制：Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。

介绍反射机制的实现前先说下java的运行机制

java程序经过编译后形成*.class文件，内含JVM的字节码。通过类加载器将字节码(*.class)加载入JVM的内存中。类加载过程主要涉及JVM的方法区。方法区存储了类的类型信息，如运行时常量池（Runtime Constant Pool）、字段和方法数据、构造函数和普通方法的字节码内容、还包括一些在类、实例、接口初始化时用到的特殊方法。这些都可以看作静态信息，每次方法被调用，在java栈中保持该方法的临时变量，当方法返回时，java栈自动撤消。JVM将类加载过程分成加载，连接，初始化三个阶段，其中连接阶段又细分为验证，准备，解析三个阶段。

Java程序开始运行前，类加载器加载类名.class，将类信息保存在运行时数据区的方法区。方法区是线程共享的，里面存储的信息有一个共同的特定就是整个程序中是唯一的。所以有关class的版本号，常量池，方法的字节码等。而类的非静态域则是对象相关的，存储在堆区，其引用(类似指针)存放在栈区

Java程序在运行时，Java运行时系统一直对所有的对象进行所谓的运行时类型标识。这项信息纪录了每个对象所属的类。虚拟机通常使用运行时类型信息选准正确方法去执行，用来保存这些类型信息的类是Class类。

下面是一段来自网上的代码告诉我们什么是反射

[java]  view plain copy print ?

1. import java.lang.reflect.Array;     
2. import java.lang.reflect.Constructor;     
3. import java.lang.reflect.Field;     
4. import java.lang.reflect.Method;     
5.     
6.     
7. /**   
8.  * Java Reflection Cookbook   
9.  *   
10.  * @author Michael Lee   
11.  * @since 2006-8-23   
12.  * @version 0.1a   
13.  */    
14.     
15. public class Reflection {     
16.     /**   
17.      * 得到某个对象的公共属性   
18.      *   
19.      * @param owner, fieldName   
20.      * @return 该属性对象   
21.      * @throws Exception   
22.      *   
23.      */    
24.     public Object getProperty(Object owner, String fieldName) throws Exception {     
25.         Class ownerClass = owner.getClass();     
26.     
27.         Field field = ownerClass.getField(fieldName);     
28.     
29.         Object property = field.get(owner);     
30.     
31.         return property;     
32.     }     
33.     
34.     /**   
35.      * 得到某类的静态公共属性   
36.      *   
37.      * @param className   类名   
38.      * @param fieldName   属性名   
39.      * @return 该属性对象   
40.      * @throws Exception   
41.      */    
42.     public Object getStaticProperty(String className, String fieldName)     
43.             throws Exception {     
44.         Class ownerClass = Class.forName(className);     
45.     
46.         Field field = ownerClass.getField(fieldName);     
47.     
48.         Object property = field.get(ownerClass);     
49.     
50.         return property;     
51.     }     
52.     
53.     
54.     /**   
55.      * 执行某对象方法   
56.      *   
57.      * @param owner   
58.      *            对象   
59.      * @param methodName   
60.      *            方法名   
61.      * @param args   
62.      *            参数   
63.      * @return 方法返回值   
64.      * @throws Exception   
65.      */    
66.     public Object invokeMethod(Object owner, String methodName, Object[] args)     
67.             throws Exception {     
68.     
69.         Class ownerClass = owner.getClass();     
70.     
71.         Class[] argsClass = new Class[args.length];     
72.     
73.         for (int i = 0, j = args.length; i < j; i++) {     
74.             argsClass[i] = args[i].getClass();     
75.         }     
76.     
77.         Method method = ownerClass.getMethod(methodName, argsClass);     
78.     
79.         return method.invoke(owner, args);     
80.     }     
81.     
82.     
83.       /**   
84.      * 执行某类的静态方法   
85.      *   
86.      * @param className   
87.      *            类名   
88.      * @param methodName   
89.      *            方法名   
90.      * @param args   
91.      *            参数数组   
92.      * @return 执行方法返回的结果   
93.      * @throws Exception   
94.      */    
95.     public Object invokeStaticMethod(String className, String methodName,     
96.             Object[] args) throws Exception {     
97.         Class ownerClass = Class.forName(className);     
98.     
99.         Class[] argsClass = new Class[args.length];     
100.     
101.         for (int i = 0, j = args.length; i < j; i++) {     
102.             argsClass[i] = args[i].getClass();     
103.         }     
104.     
105.         Method method = ownerClass.getMethod(methodName, argsClass);     
106.     
107.         return method.invoke(null, args);     
108.     }     
109.     
110.     
111.     
112.     /**   
113.      * 新建实例   
114.      *   
115.      * @param className   
116.      *            类名   
117.      * @param args   
118.      *            构造函数的参数   
119.      * @return 新建的实例   
120.      * @throws Exception   
121.      */    
122.     public Object newInstance(String className, Object[] args) throws Exception {     
123.         Class newoneClass = Class.forName(className);     
124.     
125.         Class[] argsClass = new Class[args.length];     
126.     
127.         for (int i = 0, j = args.length; i < j; i++) {     
128.             argsClass[i] = args[i].getClass();     
129.         }     
130.     
131.         Constructor cons = newoneClass.getConstructor(argsClass);     
132.     
133.         return cons.newInstance(args);     
134.     
135.     }     
136.     
137.     
138.          
139.     /**   
140.      * 是不是某个类的实例   
141.      * @param obj 实例   
142.      * @param cls 类   
143.      * @return 如果 obj 是此类的实例，则返回 true   
144.      */    
145.     public boolean isInstance(Object obj, Class cls) {     
146.         return cls.isInstance(obj);     
147.     }     
148.          
149.     /**   
150.      * 得到数组中的某个元素   
151.      * @param array 数组   
152.      * @param index 索引   
153.      * @return 返回指定数组对象中索引组件的值   
154.      */    
155.     public Object getByArray(Object array, int index) {     
156.         return Array.get(array,index);     
157.     }     
158. }