Snowberg

 

Java中的RTTI与反射机制

运行时类型识别(Run-time Type Identification, RTTI)主要有两种方式，一种是我们在编译时和运行时已经知道了所有的类型，另外一种是功能强大的“反射”机制。

要理解RTTI在Java中的工作原理，首先必须知道类型信息在运行时是如何表示的，这项工作是由“Class对象”完成的，它包含了与类有关的信息。类 是程序的重要组成部分，每个类都有一个Class对象，每当编写并编译了一个新类就会产生一个Class对象，它被保存在一个同名的.class文件中。 在运行时，当我们想生成这个类的对象时，运行这个程序的Java虚拟机(JVM)会确认这个类的Class对象是否已经加载，如果尚未加载，JVM就会根 据类名查找.class文件，并将其载入，一旦这个类的Class对象被载入内存，它就被用来创建这个类的所有对象。一般的RTTI形式包括三种：

1.传统的类型转换。如“(Apple)Fruit”，由RTTI确保类型转换的正确性，如果执行了一个错误的类型转换，就会抛出一个 ClassCastException异常。

2.通过Class对象来获取对象的类型。如

Class c = Class.forName(“Apple”);

Object o = c.newInstance();

3.通过关键字instanceof或Class.isInstance()方法来确定对象是否属于某个特定类型的实例，准确的说，应该是 instanceof / Class.isInstance()可以用来确定对象是否属于某个特定类及其所有基类的实例，这和equals() / ==不一样，它们用来比较两个对象是否属于同一个类的实例，没有考虑继承关系。


反射

如果不知道某个对象的类型，可以通过RTTI来获取，但前提是这个类型在编译时必须已知，这样才能使用RTTI来识别。即在编译时，编译器必须知道所有通 过RTTI来处理的类。

使用反射机制可以不受这个限制，它主要应用于两种情况，第一个是“基于构件的编程”，在这种编程方式中，将使用某种基于快速应用开发(RAD)的应用构建 工具来构建项目。这是现在最常见的可视化编程方法，通过代表不同组件的图标拖动到图板上来创建程序，然后设置构件的属性值来配置它们。这种配置要求构件都 是可实例化的，并且要暴露其部分信息，使得程序员可以读取和设置构件的值。当处理GUI时间的构件时还必须暴露相关方法的细细，以便RAD环境帮助程序员 覆盖这些处理事件的方法。在这里，就要用到反射的机制来检查可用的方法并返回方法名。Java通过JavaBeans提供了基于构件的编程架构。

第二种情况，在运行时获取类的信息的另外一个动机，就是希望能够提供在跨网络的远程平台上创建和运行对象的能力。这被成为远程调用(RMI)，它允许一个 Java程序将对象分步在多台机器上，这种分步能力将帮助开发人员执行一些需要进行大量计算的任务，充分利用计算机资源，提高运行速度。

Class支持反射，java.lang.reflect中包含了Field/Method/Constructor类，每个类都实现了Member接 口。这些类型的对象都是由JVM在运行时创建的，用来表示未知类里对应的成员。如可以用Constructor类创建新的对象，用get()和set() 方法读取和修改与Field对象关联的字段，用invoke()方法调用与Method对象关联的方法。同时，还可以调用getFields()、 getMethods()、getConstructors()等方法来返回表示字段、方法以及构造器的对象数组。这样，未知的对象的类信息在运行时就能 被完全确定下来，而在编译时不需要知道任何信息。

另外，RTTI有时能解决效率问题。当程序中使用多态给程序的运行带来负担的时候，可以使用RTTI编写一段代码来提高效率。

来自：http://hi.baidu.com/heroqt/blog/item/2ab1247f7450800528388a91.html

====================================================================

RTTI & Reflection

一、RTTI(RunTime Type Indentification)运行时类型识别，顾名思义，指的是在运行时如何判断对象类型的一种机制。

先来看一下，什么场合下使用RTTI。

1）          向下转型（downcasting），父类对象引用转型赋值给子类引用

2）          通过instanceof判断一个对象的类型

1.1  向下转型（downcasting）



 

((Square)square)进行了向下转型，在运行时会进行检查，如果此次转型无效，JVM会抛出ClassCastException。

1.2  instanceof

关键字instanceof可以检查某一对象是否是某一类型的实例。

 

无论是downcasting还是类型检查，在Java中都是通过Class这一类进行的。

1.3  Class类

对于Java程序中使用的每个类，Java都会将这个类的信息存储在一个Class对象中。

1）          编译时，Java创建Class对象，并将其存储.class文件中。

2）          运行时，当某一class的对象被第一次创建或者某一静态类在程序中被第一次使用，JVM会加载这个Class对象到内存中。

3）          当加载成功后，就可以用来创建这一类型的任意对象。

1.3.1 访问Class对象的方法

共有三种访问方式：

1）          Class类的静态方法forName()  (运行时进行)

Class circle_class = Class.forName(“Circle”);

2）          class literal（class原义） (编译时进行)

Class circle_class = Circle.class;

3）          对象的一些方法getClass()等  (运行时进行)

Class circle_class = circle.getClass();

Class circle_super=circle.getSuperClass(); 获得超类

Class[] circle_ifaces=circle.getInterfaces();获得实现的接口

1.3.2 Class类的方法

1）          isInterface() 判断这个类是否是一个接口类；

2）          newInstance() 新建一个类，类似于调用了无参构造函数

3）          inInstance()作用类似于instanceof关键字

4）          getName()某一Class对象获取它表示的class的名字

二、Reflection

       反射机制(reflection) 可以在运行时刻获取一个类的方法(methods)和域(fields)，以Class对象和java.lang.reflection库为支持。

2.1 java.lang.reflection库

这个库提供了Field, Method, Constructor等类，它们都实现了Member这一接口。当JVM创建一个Class对象时，它同时也创建了该Class所有成员对应的对象。

1）          Method，方法类。

变量Class cls, Method m；最左侧表示返回值类型（下面相同）。

l  Method[] = cls.getDeclaredMethods(),获得在该类中声明的方法，不包括继承来的方法；

l  Class[] = m.getParameterTypes(),获得该方法对应的参数类型；

l  Class[] = m.getExceptionTypes(), 获得该方法抛出的异常类型；

l  Class = m.getDeclaringClass(), 这个m变量所在的当前类名称；

l  Class = m. getReturnType(), 获得该方法的返回值类型。

Example:

Java代码  收藏代码
  1. package com.alibaba.reflection;  
  2.   
  3. /** 
  4.  * Created by IntelliJ IDEA. 
  5.  * User: leon 
  6.  * Date: 11-1-15 
  7.  * Time: 下午5:48 
  8.  * To change this template use File | Settings | File Templates. 
  9.  */  
  10.   
  11. //Finding Out About Methods of a Class  
  12.   
  13. import java.lang.reflect.*;  
  14.   
  15. public class Method1 {  
  16.     private int f1(Object p, int x) throws NullPointerException {  
  17.         if (p == null)  
  18.             throw new NullPointerException();  
  19.         return x;  
  20.     }  
  21.   
  22.     public static void main(String args[]) {  
  23.         try {  
  24.             Class cls = Class.forName("com.alibaba.reflection.Method1");  
  25.             Method[] methlist;  
  26.             methlist = cls.getDeclaredMethods();  
  27.             for (Method m : methlist) {  
  28.                 System.out.println("name= " + m.getName());  
  29.                 System.out.println("decl class = " + m.getDeclaringClass());  
  30.                 Class pvec[] = m.getParameterTypes();  
  31.                 for (int j = 0; j < pvec.length; j++)  
  32.                     System.out.println(new StringBuilder().append("param #").append(j).append(" ").append(pvec[j]).toString());  
  33.                 Class evec[] = m.getExceptionTypes();  
  34.                 for (int j = 0; j < evec.length; j++)  
  35.                     System.out.println("exc #" + j + " " + evec[j]);  
  36.                 System.out.println("return type = " + m.getReturnType());  
  37.                 System.out.println("-----");  
  38.             }  
  39.         } catch (Throwable e) {  
  40.             System.err.println(e);  
  41.         }  
  42.     }  
  43. }  

Result:

 

 

Java代码  收藏代码
  1. name= f1  
  2. decl class = class com.alibaba.reflection.Method1  
  3. param #0 class java.lang.Object  
  4. param #1 int  
  5. exc #0 class java.lang.NullPointerException  
  6. return type = int  
  7. -----  
  8. name= main  
  9. decl class = class com.alibaba.reflection.Method1  
  10. param #0 class [Ljava.lang.String;  
  11. return type = void  
  12. -----  

 

 

2）          Constructor 构造函数类 Constructor c;

l  Constructor[] = cls. getDeclaredConstructors (),获得在该类中声明的构造方法，不包括super()；

l  Class[] = c.getParameterTypes(),获得该构造方法对应的参数类型；

l  Class[] = c.getExceptionTypes(), 获得该构造方法抛出的异常类型；

3）          Field 域类（成员变量类）Field f;

l  Field[] = cls. getDeclaredFields(), 获得该类中声明的所有域；

l  String = f. getName(); 成员变量名

l  Class = f. getType(); 成员变量类型

l  Modifiers[] m = f.getModifiers();

Modify.toString(m); 打印出该字段的修饰符，如public static final

Example：

Java代码  收藏代码
  1. import java.lang.reflect.*;  
  2. public class Field1 {  
  3.     private double d;  
  4.     public static final int i = 37;  
  5.     String s = "testing";  
  6.     public static void main(String args[]) {  
  7.         try {  
  8.             Class cls = Class.forName("com.alibaba.reflection.Field1");  
  9.             Field fieldlist[] = cls.getDeclaredFields();  
  10.             for (int i = 0; i < fieldlist.length; i++) {  
  11.                 Field fld = fieldlist[i];  
  12.                 System.out.println("name = " + fld.getName());  
  13.                 System.out.println("decl class = " + fld.getDeclaringClass());  
  14.                 System.out.println("type = " + fld.getType());  
  15.                 int mod = fld.getModifiers();  
  16.                 System.out.println("modifiers = " + Modifier.toString(mod));  
  17.                 System.out.println("-----");  
  18.             }  
  19.         } catch (Throwable e) {  
  20.             System.err.println(e);  
  21.         }  
  22.     }  
  23. }  

 

Result:

Java代码  收藏代码
  1. name = d  
  2. decl class = class com.alibaba.reflection.Field1  
  3. type = double  
  4. modifiers = private  
  5. -----  
  6. name = i  
  7. decl class = class com.alibaba.reflection.Field1  
  8. type = int  
  9. modifiers = public static final  
  10. -----  
  11. name = s  
  12. decl class = class com.alibaba.reflection.Field1  
  13. type = class java.lang.String  
  14. modifiers =   
  15. -----  

来自：http://leonmau.iteye.com/blog/875749

posted on 2011-10-30 21:02  Snowberg  阅读(307)  评论(0)  编辑  收藏  举报

导航