RTTI & Reflection（反射机制）

最新推荐文章于 2021-02-16 07:56:32 发布

leonmau

最新推荐文章于 2021-02-16 07:56:32 发布

阅读量184

点赞数

分类专栏： Java 文章标签： JVM J# C C++ C#

Java 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

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/