Java的反射机制

一：什么是反射？

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。其中LEAD/LEAD++、OpenC++、MetaXa和OpenJava等就是基于反射机制的语言。最近，反射机制也被应用到了视窗系统、操作系统和文件系统中。（转自）

二：那么什么是JAVA的反射呢？

Java的反射机制是Java特性之一，反射机制是构建框架技术的基础所在。灵活掌握Java反射机制，对大家以后学习框架技术有很大的帮助。（开放性和原因连接是反射系统的两大基本要素。所有采用反射机制的系统（即反射系统）都希望使系统的实现更开放。可以说，实现了反射机制的系统都具有开放性，但具有开放性的系统并不一定采用了反射机制，开放性是反射系统的必要条件。一般来说，反射系统除了满足开放性条件外还必须满足原因连接（Causally-connected）。所谓原因连接是指对反射系统自描述的改变能够立即反映到系统底层的实际状态和行为上的情况，反之亦然。）

大家都知道，要让Java程序能够运行，那么就得让Java类要被Java虚拟机加载。Java类如果不被Java虚拟机加载，是不能正常运行的。现在我们运行的所有的程序都是在编译期的时候就已经知道了你所需要的那个类的已经被加载了。

Java的反射机制是在编译并不确定是哪个类被加载了，而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类。这样的特点就是反射。

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

假如我们有两个程序员，一个程序员在写程序的时候，需要使用第二个程序员所写的类，但第二个程序员并没完成他所写的类。那么第一个程序员的代码能否通过编译呢？这是不能通过编译的。利用Java反射的机制，就可以让第一个程序员在没有得到第二个程序员所写的类的时候，来完成自身代码的编译。

反射是一种强大的工具。它使您能够创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代表链接。反射允许我们在编写与执行时，使我们的程序代码能够接入装载到JVM中的类的内部信息，而不是源代码中选定的类协作的代码。这使反射成为构建灵活的应用的主要工具。但需注意的是：如果使用不当，反射的成本很高。用Java反射机制我们可以很灵活的对已经加载到Java虚拟机当中的类信息进行检测。

四：什么是class类

      要正确使用Java反射机制就得使用java.lang.Class这个类。它是Java反射机制的起源。当一个类被加载以后，Java虚拟机就会自动产生一个Class对象。通过这个Class对象我们就能获得加载到虚拟机当中这个Class对象对应的方法、成员以及构造方法的声明和定义等信息。

 

五：反射API

      u反射API用于反应在当前Java虚拟机中的类、接口或者对象信息

u功能
—获取一个对象的类信息.

      —获取一个类的访问修饰符、成员、方法、构造方法以及超类的信息.

      —检获属于一个接口的常量和方法声明.

      —创建一个直到程序运行期间才知道名字的类的实例.

      —获取并设置一个对象的成员，甚至这个成员的名字是
   在程序运行期间才知道.

      —检测一个在运行期间才知道名字的对象的方法

那么如何利用反射API在运行的时候知道一个类的信息呢？

 

代码示例：

package day5demo;

 

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import javax.swing.JOptionPane;

 

/**

 

 *本类用于测试反射API，利用用户输入类的全路径，

 

*找到该类所有的成员方法和成员属性

 

 */

 

publicclassday5demo1 {

 

   publicday5demo1(){

      String classInfo=JOptionPane.showInputDialog(null,"输入类全路径");//要求用户输入类的全路径

      try {

      Class cla=Class.forName(classInfo);//根据类的全路径进行类加载，返回该类的Class对象

          Method[]method=cla.getDeclaredMethods();//利用得到的Class对象的自审，返回方法对象集合

          for(Method me:method){//遍历该类方法的集合

            System.out.println(me.toString());//打印方法信息

          }

          System.out.println("********");

          Field[]field=cla.getDeclaredFields();//利用得到的Class对象的自审，返回属性对象集合

          for(Field me:field){//遍历该类属性的集合

             System.out.println(me.toString());//打印属性信息

          }

      } catch (ClassNotFoundException e) {

        e.printStackTrace();

      }

   }

   publicstaticvoidmain(String[] args) {

     newday5demo1();

  }

}

运行的时候，我们输入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

 

…………

 

   大家可以发现，类的全路径是在程序运行的时候，由用户输入的。所以虚拟机事先并不知道所要加载类的信息，这就是利用反射机制来对用户输入的类全路径来对类自身的一个自审。从而探知该类所拥有的方法和属性。

 

通过上面代码，大家可以知道编译工具为什么能够一按点就能列出用户当前对象的属性和方法了。它是先获得用户输入对象的字符串，然后利用反射原理来对这样的类进行自审，从而列出该类的方法和属性。

获得Class对象的方法

 

u如果一个类的实例已经得到，你可以使用

      【Class c = 对象名.getClass();】

     例： TextField t = new TextField();

             Class c = t.getClass();

             Class s = c.getSuperclass();

 

u如果你在编译期知道类的名字，你可以使用如下的方法

Class c =java.awt.Button.class;
或者

        Class c = Integer.TYPE;

 

u如果类名在编译期不知道,但是在运行期可以获得,你可以使用下面的方法

         Class c = Class.forName(strg);

  这样获得Class类对象的方法，其实是利用反射API把指定字符串的类加载到内存中，所以也叫类加载器加载方法。这样的话，它会把该类的静态方法和静态属性，以及静态代码全部加载到内存中。但这时候，对象还没有产生。所以为什么静态方法不能访问非静态属性和方法。因为静态方法和属性产生的时机在非静态属性和方法之前。

 

代码示例：

package  com; 

publicclass MyTest {

   publicstaticvoid main(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(Exception e){

          e.printStackTrace();

       }

      TestOne two=new TestOne();

  System.out.println(one.getClass() == two.getClass());//比较两个TestOne对象的Class对象是否是同一个对象，在这里结果是true。说明如果两个对象的类型相同，那么它们会有相同的Class对象

    }

}

 

class TestOne{

   static{

      System.out.println("静态代码块运行");

    }

    TestOne(){

      System.out.println("构造方法");

    }

}

 以上代码过行的结果是：

静态代码块运行

***********

构造方法

构造方法

 

代码分析：

 

在进行Class.forName("com.TestOne")的时候，实际上是对com.TestOne进行类加载，这时候，会把静态属性、方法以及静态代码块都加载到内存中。所以这时候会打印出"静态代码块运行"。但这时候，对象却还没有产生。所以"构造方法"这几个字不会打印。当执行cla.newInstance()的时候，就是利用反射机制将Class对象生成一个该类的一个实例。这时候对象就产生了。所以打印"构造方法"。当执行到TestOnetwo=new TestOne()语句时，又生成了一个对象。但这时候类已经加载完毕，静态的东西已经加载到内存中，而静态代码块只执行一次，所以不用再去加载类，所以只会打印"构造方法"，而"静态代码块运行"不会打印。

 

 

反射机制不但可以例出该类对象所拥有的方法和属性，还可以获得该类的构造方法及通过构造方法获得实例。也可以动态的调用这个实例的成员方法。

 

代码示例：

 

package reflect;

 

importjava.lang.reflect.Constructor;

 /**

 *

 *本类测试反射获得类的构造器对象，

 *并通过类构造器对象生成该类的实例

 *

 */

publicclassConstructorTest {

   public static voidmain(String[] args) {

      try {

          //获得指定字符串类对象

          Class cla=Class.forName("reflect.Tests");

          //设置Class对象数组，用于指定构造方法类型

          Class[] cl=new Class[]{int.class,int.class};

          

          //获得Constructor构造器对象。并指定构造方法类型

          Constructor con=cla.getConstructor(cl);

          

          //给传入参数赋初值

          Object[] x={new Integer(33),new Integer(67)};

          

          //得到实例

          Object obj=con.newInstance(x);

       }catch(Exception e) {

          e.printStackTrace();

       }

    }

}

 

class Tests{

   public Tests(int x,inty){

       System.out.println(x+"   "+y);

    }

}

 

 

运行的结果是”33    67”。说明我们已经生成了Tests这个类的一个对象。

 

六：总结

精辟：反射就是把JAVA类中的所有成分映射成相应的java类。例如一个java类中用一个class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的java类来表示。表示JAVA类的class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息。这些信息就是用相应类的实例对象来表示，它们是Field,Method,Contructor,Package等等。

 

 

一：什么是反射？
反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。其中LEAD/LEAD++ 、OpenC++ 、MetaXa和OpenJava等就是基于反射机制的语言。最近，反射机制也被应用到了视窗系统、操作系统和文件系统中。（转自）
二：那么什么是JAVA的反射呢？
Java的反射机制是Java特性之一，反射机制是构建框架技术的基础所在。灵活掌握Java反射机制，对大家以后学习框架技术有很大的帮助。（开放性和原因连接是反射系统的两大基本要素。所有采用反射机制的系统（即反射系统）都希望使系统的实现更开放。可以说，实现了反射机制的系统都具有开放性，但具有开放性的系统并不一定采用了反射机制，开放性是反射系统的必要条件。一般来说，反射系统除了满足开放性条件外还必须满足原因连接（Causally-connected）。所谓原因连接是指对反射系统自描述的改变能够立即反映到系统底层的实际状态和行为上的情况，反之亦然。）
大家都知道，要让Java程序能够运行，那么就得让Java类要被Java虚拟机加载。Java类如果不被Java虚拟机加载，是不能正常运行的。现在我们运行的所有的程序都是在编译期的时候就已经知道了你所需要的那个类的已经被加载了。
Java的反射机制是在编译并不确定是哪个类被加载了，而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类。这样的特点就是反射。
三：那么Java反射有什么作用呢？
假如我们有两个程序员，一个程序员在写程序的时候，需要使用第二个程序员所写的类，但第二个程序员并没完成他所写的类。那么第一个程序员的代码能否通过编译呢？这是不能通过编译的。利用Java反射的机制，就可以让第一个程序员在没有得到第二个程序员所写的类的时候，来完成自身代码的编译。
反射是一种强大的工具。它使您能够创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代表链接。反射允许我们在编写与执行时，使我们的程序代码能够接入装载到JVM中的类的内部信息，而不是源代码中选定的类协作的代码。这使反射成为构建灵活的应用的主要工具。但需注意的是：如果使用不当，反射的成本很高。用Java反射机制我们可以很灵活的对已经加载到Java虚拟机当中的类信息进行检测。
四：什么是class类
要正确使用Java反射机制就得使用java.lang.Class这个类。它是Java反射机制的起源。当一个类被加载以后，Java虚拟机就会自动产生一个Class对象。通过这个Class对象我们就能获得加载到虚拟机当中这个Class对象对应的方法、成员以及构造方法的声明和定义等信息。

五：反射API
反射API用于反应在当前Java虚拟机中的类、接口或者对象信息
功能
—获取一个对象的类信息.
—获取一个类的访问修饰符、成员、方法、构造方法以及超类的信息.
—检获属于一个接口的常量和方法声明.
—创建一个直到程序运行期间才知道名字的类的实例.
—获取并设置一个对象的成员，甚至这个成员的名字是
在程序运行期间才知道.
—检测一个在运行期间才知道名字的对象的方法
那么如何利用反射API在运行的时候知道一个类的信息呢？

代码示例：
package day5demo;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import javax.swing.JOptionPane;

/**

*本类用于测试反射API，利用用户输入类的全路径，

*找到该类所有的成员方法和成员属性

*/

public class day5demo1 {

public day5demo1(){
String classInfo=JOptionPane.showInputDialog(null,"输入类全路径");//要求用户输入类的全路径
try {
Class cla=Class.forName(classInfo);//根据类的全路径进行类加载，返回该类的Class对象
Method[] method=cla.getDeclaredMethods();//利用得到的Class对象的自审，返回方法对象集合
for(Method me:method){//遍历该类方法的集合
System.out.println(me.toString());//打印方法信息
}
System.out.println("********");
Field[] field=cla.getDeclaredFields();//利用得到的Class对象的自审，返回属性对象集合
for(Field me:field){ //遍历该类属性的集合
System.out.println(me.toString());//打印属性信息
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new day5demo1();
}
}
运行的时候，我们输入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

…………

大家可以发现，类的全路径是在程序运行的时候，由用户输入的。所以虚拟机事先并不知道所要加载类的信息，这就是利用反射机制来对用户输入的类全路径来对类自身的一个自审。从而探知该类所拥有的方法和属性。

通过上面代码，大家可以知道编译工具为什么能够一按点就能列出用户当前对象的属性和方法了。它是先获得用户输入对象的字符串，然后利用反射原理来对这样的类进行自审，从而列出该类的方法和属性。
获得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;
public class MyTest {
public static void main(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(Exception e){
e.printStackTrace();
}
TestOne two=new TestOne();
System.out.println(one.getClass() == two.getClass());//比较两个TestOne对象的Class对象是否是同一个对象，在这里结果是true。说明如果两个对象的类型相同，那么它们会有相同的Class对象
}
}

class TestOne{
static{
System.out.println("静态代码块运行");
}
TestOne(){
System.out.println("构造方法");
}
}
以上代码过行的结果是：
静态代码块运行
***********
构造方法
构造方法

代码分析：

在进行Class.forName("com.TestOne")的时候，实际上是对com.TestOne进行类加载，这时候，会把静态属性、方法以及静态代码块都加载到内存中。所以这时候会打印出"静态代码块运行"。但这时候，对象却还没有产生。所以"构造方法"这几个字不会打印。当执行cla.newInstance()的时候，就是利用反射机制将Class对象生成一个该类的一个实例。这时候对象就产生了。所以打印"构造方法"。当执行到TestOne two=new TestOne()语句时，又生成了一个对象。但这时候类已经加载完毕，静态的东西已经加载到内存中，而静态代码块只执行一次，所以不用再去加载类，所以只会打印"构造方法"，而"静态代码块运行"不会打印。


反射机制不但可以例出该类对象所拥有的方法和属性，还可以获得该类的构造方法及通过构造方法获得实例。也可以动态的调用这个实例的成员方法。

代码示例：

package reflect;

import java.lang.reflect.Constructor;
/**
*
* 本类测试反射获得类的构造器对象，
* 并通过类构造器对象生成该类的实例
*
*/
public class ConstructorTest {
public static void main(String[] args) {
try {
//获得指定字符串类对象
Class cla=Class.forName("reflect.Tests");
//设置Class对象数组，用于指定构造方法类型
Class[] cl=new Class[]{int.class,int.class};

//获得Constructor构造器对象。并指定构造方法类型
Constructor con=cla.getConstructor(cl);

//给传入参数赋初值
Object[] x={new Integer(33),new Integer(67)};

//得到实例
Object obj=con.newInstance(x);
} catch (Exception e) {
e.printStackTrace();
}
}
}

class Tests{
public Tests(int x,int y){
System.out.println(x+" "+y);
}
}


运行的结果是” 33 67”。说明我们已经生成了Tests这个类的一个对象。

六：总结
精辟：反射就是把JAVA类中的所有成分映射成相应的java类。例如一个java类中用一个class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的java类来表示。表示JAVA类的class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息。这些信息就是用相应类的实例对象来表示，它们是Field,Method,Contructor,Package等等。