RTTI & Reflection（反射机制）

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:

package com.alibaba.reflection;

/**
 * Created by IntelliJ IDEA.
 * User: leon
 * Date: 11-1-15
 * Time: 下午5:48
 * To change this template use File | Settings | File Templates.
 */

//Finding Out About Methods of a Class

import java.lang.reflect.*;

public class Method1 {
    private int f1(Object p, int x) throws NullPointerException {
        if (p == null)
            throw new NullPointerException();
        return x;
    }

    public static void main(String args[]) {
        try {
            Class cls = Class.forName("com.alibaba.reflection.Method1");
            Method[] methlist;
            methlist = cls.getDeclaredMethods();
            for (Method m : methlist) {
                System.out.println("name= " + m.getName());
                System.out.println("decl class = " + m.getDeclaringClass());
                Class pvec[] = m.getParameterTypes();
                for (int j = 0; j < pvec.length; j++)
                    System.out.println(new StringBuilder().append("param #").append(j).append(" ").append(pvec[j]).toString());
                Class evec[] = m.getExceptionTypes();
                for (int j = 0; j < evec.length; j++)
                    System.out.println("exc #" + j + " " + evec[j]);
                System.out.println("return type = " + m.getReturnType());
                System.out.println("-----");
            }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

Result:

 

 

name= f1
decl class = class com.alibaba.reflection.Method1
param #0 class java.lang.Object
param #1 int
exc #0 class java.lang.NullPointerException
return type = int
-----
name= main
decl class = class com.alibaba.reflection.Method1
param #0 class [Ljava.lang.String;
return type = void
-----

 

 

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：

import java.lang.reflect.*;
public class Field1 {
    private double d;
    public static final int i = 37;
    String s = "testing";
    public static void main(String args[]) {
        try {
            Class cls = Class.forName("com.alibaba.reflection.Field1");
            Field fieldlist[] = cls.getDeclaredFields();
            for (int i = 0; i < fieldlist.length; i++) {
                Field fld = fieldlist[i];
                System.out.println("name = " + fld.getName());
                System.out.println("decl class = " + fld.getDeclaringClass());
                System.out.println("type = " + fld.getType());
                int mod = fld.getModifiers();
                System.out.println("modifiers = " + Modifier.toString(mod));
                System.out.println("-----");
            }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

 

Result:

name = d
decl class = class com.alibaba.reflection.Field1
type = double
modifiers = private
-----
name = i
decl class = class com.alibaba.reflection.Field1
type = int
modifiers = public static final
-----
name = s
decl class = class com.alibaba.reflection.Field1
type = class java.lang.String
modifiers = 
-----

 

Reference:

http://java.sun.com/developer/technicalArticles/ALT/Reflection/