总结: 十分钟深入理解Java反射机制
import java.lang.reflect.*;
class LatentReflection{
public static void main(String[] args){
Reflect.perform(new Dog());
Reflect.perform(new Cat());
Reflect.perform(new Fish());
}
}
//反射
class Dog{
public void speak(){
System.out.println("汪汪汪!!!");
}
public void eat(){
System.out.println("吃东西");
}
}
class Cat{
public void speak(){
System.out.println("喵~喵~喵~");
}
public void eat(){
System.out.println("吃东西");
}
}
class Fish{
public void eat(){
System.out.println("吃东西");
}
public void swim(){
System.out.println("游泳");
}
}
class Reflect{
public static void perform(Object speaker){
Class spkr = speaker.getClass();
try{
try{
Method speak = spkr.getMethod("speak");
speak.invoke(speaker);
}catch(NoSuchMethodException e){
System.out.println(speaker + "cannot speak");
}
try{
Method eat =spkr.getMethod("eat");
eat.invoke(speaker);
}catch(NoSuchMethodException e){
System.out.println(speaker + "cannot eat");
}
}catch(Exception e){
throw new RuntimeException(speaker.toString(),e);
}
}
}运行结果
汪汪汪!!!
吃东西
喵~喵~喵~
吃东西
Fish@7852e922cannot speak
吃东西上例中,这些类完全是彼此分离的,没有任何的公共基类(除了Object)或接口.通过反射,Reflect.perform();能动态地确定所需要的方法是否可用,并调用它们.它甚至能够处理dog只具有一个必须的方法这一事实,并能够部分实现其目标.
通过上面这个例子,应该可以简单的了解到什么是Java的反射机制了.
Java反射提供的功能.
1.在运行时判断任何一个对象所属的类
2.在运行时构造任何一个类的对象
3.在运行时判断任何一个类所具有的的成员变量和方法
4.在运行时调用任何一个对象的成员变量和方法
5.生成动态代理
Java的反射机制它知道类的基本结构，这种对Java类结构探知的能力，我们称为Java类的“自审”。大家都用过Jcreator和eclipse。当我们构建出一个对象的时候，去调用该对象的方法和属性的时候。一按点，编译工具就会自动的把该对象能够使用的所有的方法和属性全部都列出来，供用户进行选择。这就是利用了Java反射的原理，是对我们创建对象的探知、自审
Class类
要正确使用Java反射机制就得使用java.lang.Class这个类。它是Java反射机制的起源。当一个类被加载以后，Java虚拟机就会自动产生一个Class对象。通过这个Class对象我们就能获得加载到虚拟机当中这个Class对象对应的方法、成员以及构造方法的声明和定义等信息。
反射API
反射API用于反应在当前Java虚拟机中的类、接口或者对象信息
功能----获取一个对象的类信息.
获取一个类的访问修饰符、成员、方法、构造方法以及超类的信息.
检获属于一个接口的常量和方法声明.
创建一个直到程序运行期间才知道名字的类的实例.
获取并设置一个对象的成员，甚至这个成员的名字是在程序运行期间才知道.
检测一个在运行期间才知道名字的对象的方法
利用Java反射机制我们可以很灵活的对已经加载到Java虚拟机当中的类信息进行检测。当然这种检测在对运行的性能上会有些减弱，所以什么时候使用反射，就要靠业务的需求、大小，以及经验的积累来决定。
那么如何利用反射API在运行的时候知道一个类的信息呢？
代码示例：
importjava.lang.reflect.Field;
importjava.lang.reflect.Method;
importjavax.swing.JOptionPane;
/**
*本类用于测试反射API，利用用户输入类的全路径，
*找到该类所有的成员方法和成员属性
*/
publicclassMyTest {
/**
*构造方法
*/
publicMyTest(){
StringclassInfo=JOptionPane.showInputDialog(null,"输入类全路径");//要求用户输入类的全路径
try{
Classcla=Class.forName(classInfo);//根据类的全路径进行类加载，返回该类的Class对象
Method[]method=cla.getDeclaredMethods();//利用得到的Class对象的自审，返回方法对象集合
for(Methodme:method){//遍历该类方法的集合
System.out.println(me.toString());//打印方法信息
}
System.out.println("********");
Field[]field=cla.getDeclaredFields();//利用得到的Class对象的自审，返回属性对象集合
for(Fieldme:field){//遍历该类属性的集合
System.out.println(me.toString());//打印属性信息
}
}catch(ClassNotFoundException e) {
e.printStackTrace();
}
}
publicstaticvoidmain(String[] args) {
newMyTest();
}
}
运行的时候，我们输入javax.swing.JFrame，那么运行结果如下：
public void javax.swing.JFrame.remove(java.awt.Component)
public void javax.swing.JFrame.update(java.awt.Graphics)
…………
********
public static final int javax.swing.JFrame.EXIT_ON_CLOSE
private int javax.swing.JFrame.defaultCloseOperation
…………大家可以发现，类的全路径是在程序运行的时候，由用户输入的。所以虚拟机事先并不知道所要加载类的信息，这就是利用反射机制来对用户输入的类全路径来对类自身的一个自审。从而探知该类所拥有的方法和属性。
通过上面代码，大家可以知道编译工具为什么能够一按点就能列出用户当前对象的属性和方法了。它是先获得用户输入对象的字符串，然后利用反射原理来对这样的类进行自审，从而列出该类的方法和属性。
使用反射机制的步骤：导入java.lang.relfect包
遵循三个步骤
第一步是获得你想操作的类的java.lang.Class对象
第二步是调用诸如getDeclaredMethods的方法
第三步使用反射API来操作这些信息
获得Class对象的方法
如果一个类的实例已经得到，你可以使用
【Class c =对象名.getClass();】
例：
TextField t = new TextField();
Class c = t.getClass();
Class s = c.getSuperclass();如果你在编译期知道类的名字，你可以使用如下的方法
Class c = java.awt.Button.class;或者
Class c = Integer.TYPE;如果类名在编译期不知道,但是在运行期可以获得,你可以使用下面的方法
Class c = Class.forName(strg);
这样获得Class类对象的方法，其实是利用反射API把指定字符串的类加载到内存中，所以也叫类加载器加载方法。这样的话，它会把该类的静态方法和静态属性，以及静态代码全部加载到内存中。但这时候，对象还没有产生。所以为什么静态方法不能访问非静态属性和方法。因为静态方法和属性产生的时机在非静态属性和方法之前。
代码示例：
package com;
publicclassMyTest {
publicstaticvoidmain(String[]args) {
TestOne one=null;
try{
Class cla=Class.forName("com.TestOne");//进行com.TestOne类加载，返回一个Class对象
System.out.println("********");
one=(TestOne)cla.newInstance();//产生这个Class类对象的一个实例，调用该类无参的构造方法，作用等同于new TestOne()
}catch(Exceptione){
e.printStackTrace();
}
TestOne two=newTestOne();
System.out.println(one.getClass()== two.getClass());//比较两个TestOne对象的Class对象是否是同一个对象，在这里结果是true。说明如果两个对象的类型相同，那么它们会有相同的Class对象
}
}
classTestOne{
static{
System.out.println("静态代码块运行");
}
TestOne(){
System.out.println("构造方法");
}
}以上代码过行的结果是：
静态代码块运行
***********
构造方法
构造方法代码分析：
在进行Class.forName("com.TestOne")的时候，实际上是对com.TestOne进行类加载，这时候，会把静态属性、方法以及静态代码块都加载到内存中。所以这时候会打印出"静态代码块运行"。但这时候，对象却还没有产生。所以"构造方法"这几个字不会打印。当执行cla.newInstance()的时候，就是利用反射机制将Class对象生成一个该类的一个实例。这时候对象就产生了。所以打印"构造方法"。当执行到TestOnetwo=newTestOne()语句时，又生成了一个对象。但这时候类已经加载完毕，静态的东西已经加载到内存中，而静态代码块只执行一次，所以不用再去加载类，所以只会打印"构造方法"，而"静态代码块运行"不会打印。
反射机制不但可以例出该类对象所拥有的方法和属性，还可以获得该类的构造方法及通过构造方法获得实例。也可以动态的调用这个实例的成员方法。
代码示例：
packagereflect;
importjava.lang.reflect.Constructor;
/**
*
*本类测试反射获得类的构造器对象，
*并通过类构造器对象生成该类的实例
*
*/
publicclassConstructorTest {
publicstaticvoidmain(String[] args) {
try{
//获得指定字符串类对象
Classcla=Class.forName("reflect.Tests");
//设置Class对象数组，用于指定构造方法类型
Class[]cl=newClass[]{int.class,int.class};
//获得Constructor构造器对象。并指定构造方法类型
Constructorcon=cla.getConstructor(cl);
//给传入参数赋初值
Object[]x={newInteger(33),newInteger(67)};
//得到实例
Objectobj=con.newInstance(x);
}catch(Exception e) {
e.printStackTrace();
}
}
}
classTests{
publicTests(intx,inty){
System.out.println(x+" "+y);
}
}
运行的结果是”33 67”。说明我们已经生成了Tests这个类的一个对象。
同样，也可以通过反射模式，来执行Java类的方法
代码示例：
packagereflect;
importjava.lang.reflect.Method;
/**
*
*本类测试反射获得类的方法对象，
*并通过类对象和类方法对象，运行该方法
*
*/
publicclassMethodTest {
publicstaticvoidmain(String[] args) {
try{
//获得窗体类的Class对象
Classcla=Class.forName("javax.swing.JFrame");
//生成窗体类的实例
Objectobj=cla.newInstance();
//获得窗体类的setSize方法对象，并指定该方法参数类型为int,int
MethodmethodSize=cla.getMethod("setSize",newClass[]{int.class,int.class});
/*执行setSize()方法，并传入一个Object[]数组对象，作为该方法参数，等同于窗体对象.setSize(300,300);*/
methodSize.invoke(obj,newObject[]{newInteger(300),newInteger(300)});
//获得窗体类的setSize方法对象，并指定该方法参数类型为boolean
MethodmethodVisible=cla.getMethod("setVisible",newClass[]{boolean.class});
/*执行setVisible()方法，并传入一个Object[]数组对象，作为该方法参数。等同于窗体对象.setVisible(true);*/
methodVisible.invoke(obj,newObject[]{newBoolean(true)});
}catch(Exception e) {
e.printStackTrace();
}
}
}
反射机制是框架技术的原理和核心部分。通过反射机制我们可以动态的通过改变配置文件(以后是XML文件)的方式来加载类、调用类方法，以及使用类属性。这样的话，对于编码和维护带来相当大的便利。在程序进行改动的时候，也只会改动相应的功能就行了，调用的方法是不用改的。更不会一改就改全身。