Java反射

反射是什么

在计算机科学中，反射是指计算机程序在运行时（Run time）可以访问、检测和修改它本身状态或行为的一种能力。用比喻来说，反射就是程序在运行的时候能够“观察”并且修改自己的行为。

反射是Java编程语言的一个特性，它允许运行时的Java程序检测自身状态，并且修改程序的内部属性。

一个反射的典型使用就是IDE，我们在编写代码的时候，编译工具会自动把该对象能够使用的所有的方法和属性全部列出来，供我们选择使用。这就是利用了Java的反射原理，是对我们创建对象的探知、自审。

一个简单例子

为了看看反射如何工作，我们来看看下面的例子：

import java.lang.reflect.Method;

public class DumpMethods {

    public static void main(String args[]) {
        try {
            Class c = Class.forName(args[0]);
            Method m[] = c.getDeclaredMethods();
            for (int i = 0; i < m.length; i++) {
                System.out.println(m[i].toString());
            }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

命令行下编译后执行：

javac DumpMethods.java

java DumpMethods java.util.Stack

输出如下：

oyty-mbp:src oyty$ java DumpMethods java.util.Stack
public java.lang.Object java.util.Stack.push(java.lang.Object)
public synchronized java.lang.Object java.util.Stack.pop()
public synchronized java.lang.Object java.util.Stack.peek()
public boolean java.util.Stack.empty()
public synchronized int java.util.Stack.search(java.lang.Object)

上面打印的就是类java.util.Stack的所有方法名，并且包含完整的参数和返回值类型。

这个程序使用class.forName加载了指定的类，然后调用getDeclaredMethods获取在类中定义的所有方法。java.lang.reflect.Method是表示单一类方法的类。

使用反射

反射的相关类，例如Method，存在于包java.lang.reflect中。要使用这些类，你必须遵循下面的三个步骤：

第一步，获取你要操作的类的java.lang.Class对象

获取Class对象的一种方式：

// 获得String类的Class对象
Class c = Class.forName("java.lang.String");

另一种方式：

Class c = int.class;
or
Class c = Integer.TYPE;
第二步，调用相关方法

比如，你可以调用getDeclaredMethods方法来获取类里面所有定义的方法。

第三步

一旦拿到第二步获取到的信息，就可以使用反射的API去操作这些信息。例如：

Class c = Class.forName("java.lang.String");    
Method m[] = c.getDeclaredMethods();    
System.out.println(m[0].toString());

上面的程序序列将会打印在String里面定义的第一个方法。

模拟instanceof操作符

一旦我们拿到了Class的信息，通常下一步我们会做一些基本的问题，比如用Class.isInstance方法来模拟instanceof操作符。

class A {}

public class InstanceA {
    public static void main(String args[]) {
        try {
            Class cls = Class.forName("A");
            boolean b1 = cls.isInstance(new Integer(37));
            System.out.println(b1);
            boolean b2 = cls.isInstance(new A());
            System.out.println(b2);
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

在上面的例子中，类A的Class对象被创建，然后一些类的实例对象被用来检测他们是否是A的实例。Integer(37)显然不是，new 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("Method1");

            Method methlist[] = cls.getDeclaredMethods();
            for (int i = 0; i < methlist.length; i++) {
                Method m = methlist[i];
                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("param #" + j + " " + pvec[j]);
                }
                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);
        }
    }
}

代码输出为：

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

上面的程序，首先获取到了method1的Class对象，然后调用getDeclaredMethods方法获取类中定义的Method对象数组，这些方法包含public、protected，package和private方法。如果你使用getMethods方法而不是getDeclaredMethods方法，你也将会获得继承的方法信息。需要注意的getMethods返回的是包含父类属性中修饰符为public的方法。
一旦获取到了方法数组，就很容易得到每个方法的参数类型，异常类型和返回类型。

获取类的构造方法

反射还可以用来获取一个类的构造方法信息：

import java.lang.reflect.*;

public class Constructor1 {

    public Constructor1() {
    }

    protected Constructor1(int i, double d) {
    }

    public static void main(String args[]) {
        try {
            Class cls = Class.forName("Constructor1");

            Constructor ctorlist[] = cls.getDeclaredConstructors();
            for (int i = 0; i < ctorlist.length; i++) {
                Constructor ct = ctorlist[i];
                System.out.println("name = " + ct.getName());
                System.out.println("decl class = " + ct.getDeclaringClass());

                Class pvec[] = ct.getParameterTypes();
                for (int j = 0; j < pvec.length; j++) {
                    System.out.println("param #" + j + " " + pvec[j]);
                }

                Class evec[] = ct.getExceptionTypes();
                for (int j = 0; j < evec.length; j++) {
                    System.out.println("exc #" + j + " " + evec[j]);
                }
                System.out.println("-----");
            }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

输出为：

name = Constructor1
decl class = class Constructor1
-----
name = Constructor1
decl class = class Constructor1
param #0 int
param #1 double
-----

这里没有获取返回类型信息，因为构造方法并没有返回类型。

获取类的属性

我们还可以获得类中定义的属性：

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("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);
        }
    }
}

输出为：

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

这里使用了Modifier，这是表示属性的修饰符的类。
我们可以使用getDeclaredFields获取类中定义的属性，也可以使用getFields额外获取父类中定义的属性。需要注意的后者返回的是包含父类属性中修饰符为public的属性。

通过方法名调用方法

目前为止，上面的一些例子都是展示如何获取类的信息，还有一些其它的使用反射的方式，比如调用一个特定的方法。
看看下面的代码：

import java.lang.reflect.*;

public class Method2 {

    public int add(int a, int b) {
        return a + b;
    }

    public static void main(String args[]) {
        try {
            Class cls = Class.forName("Method2");
            Class partypes[] = new Class[2];
            partypes[0] = Integer.TYPE;
            partypes[1] = Integer.TYPE;
            Method meth = cls.getMethod("add", partypes);
            Method2 methobj = new Method2();
            Object arglist[] = new Object[2];
            arglist[0] = new Integer(37);
            arglist[1] = new Integer(47);
            Object retobj = meth.invoke(methobj, arglist);
            Integer retval = (Integer) retobj;
            System.out.println(retval.intValue());
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

试想一下，一个程序想要去调用add方法，但是直到程序执行的时候才知道这个方法，所以在程序执行的时候，方法的名字才被指定。
getMethod用来在Class中寻找有两个Integer类型参数和方法名为add的方法。一旦这个方法被找到，并且赋值给Method对象后，就可以在合适的参数下调用。

创建新的对象

方法的调用和构造方法的调用是不一样的，因为你调用一个构造方法，实际上是创建了一个新的对象。准确来说，创建一个新的对象包含了内存分配和对象构建。
通过构造方法创建对象：

import java.lang.reflect.*;

public class Constructor2 {
    public Constructor2() {
    }

    public Constructor2(int a, int b) {
        System.out.println("a = " + a + " b = " + b);
    }

    public static void main(String args[]) {
        try {
            Class cls = Class.forName("Constructor2");
            Class partypes[] = new Class[2];
            partypes[0] = Integer.TYPE;
            partypes[1] = Integer.TYPE;
            Constructor ct = cls.getConstructor(partypes);
            Object arglist[] = new Object[2];
            arglist[0] = new Integer(37);
            arglist[1] = new Integer(47);
            Object retobj = ct.newInstance(arglist);
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

上面程序找到了一个有特定参数类型的构造方法，执行调用后，创建了对象的一个新的实例。这种方式创建对象的价值在于它是完全动态的，实在程序执行时寻找和执行构造方法，而不是在编译时。

修改属性值

反射的另一个用法是修改对象属性的值，这也是反射的一个动态特性。在程序执行时通过属性名寻找属性并且修改它的值。

import java.lang.reflect.*;

public class Field2 {
    public double d;

    public static void main(String args[]) {
        try {
            Class cls = Class.forName("Field2");
            Field fld = cls.getField("d");
            Field2 f2obj = new Field2();
            System.out.println("d = " + f2obj.d);
            fld.setDouble(f2obj, 12.34);
            System.out.println("d = " + f2obj.d);
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

在上面例子中，属性d的值被修改成了12.34。

使用数组

反射的最后一个用法是创建和使用数组。数组是Java语言中的一个特殊类型，一个数组引用可以赋值给一个Object引用。

import java.lang.reflect.*;

public class Array1 {
    public static void main(String args[]) {
        try {
            Class cls = Class.forName("java.lang.String");
            Object arr = Array.newInstance(cls, 10);
            Array.set(arr, 5, "this is a test");
            String s = (String) Array.get(arr, 5);
            System.out.println(s);
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

上面程序创建了长度为10的String类型的数组，然后将数组中索引为5的值赋值为一个字符串。
更复杂点的看看下面：

import java.lang.reflect.*;

public class Array2 {
    public static void main(String args[]) {
        int dims[] = new int[]{5, 10, 15};
        Object arr = Array.newInstance(Integer.TYPE, dims);
        Object arrobj = Array.get(arr, 3);
        System.out.println(arrobj);
        Class cls = arrobj.getClass().getComponentType();
        System.out.println(cls);
        arrobj = Array.get(arrobj, 5);
        Array.setInt(arrobj, 10, 37);
        int arrcast[][][] = (int[][][]) arr;
        System.out.println(arrcast[3][5][10]);
    }
}

上面的程序创建了一个5x10x15的三维int类型数组。然后将位置[3][5][10]设置为37，一个多维数组实际上就是数组的数组，所以第一次Array.get后得到的是一个10x15的二维数组。

访问私有成员变量和方法

在访问private或protected成员变量和方法时，须通过setAccessible(boolean assess)方法取消Java语言检查，否则将抛出IllegalAccessException。如果JVM的安全管理器设置了相应的安全机制，那么调用该方法将抛出SecurityException。

总结

Java的反射支持动态获取类的信息，数据结构，并且在程序执行时动态修改。这个特性非常强大。

参考：
http://www.oracle.com/technetwork/articles/java/javareflection-1536171.html

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 206,723评论 6赞 481
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 88,485评论 2赞 382
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 152,998评论 0赞 344
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 55,323评论 1赞 279
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 64,355评论 5赞 374
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,079评论 1赞 285
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,389评论 3赞 400
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,019评论 0赞 259
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,519评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,971评论 2赞 325
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,100评论 1赞 333
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,738评论 4赞 324
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,293评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,289评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,517评论 1赞 262
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,547评论 2赞 354
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,834评论 2赞 345