java 运行时类型识别(RTTI) - 2 - 反射
2012-07-30 12:55
561 查看
java 运行时类型识别(RTTI) - 1 - Class与instanceof
java 运行时类型识别(RTTI) - 2 - 反射
本文将叙述如何运行时查看类信息,其中包括变量,方法,以及通过反射修改变量,执行方法等
包括如何反射匿名内部类及如何执行其方法,但是笔者强烈不建议这么做,这里只是演示反射而已
下面是一个测试类
其中包括了普通内部类,静态内部类,内部匿名类,接口等
其中外部类Outer没有默认构造器,String reflect.Outer.Inner.getName()是private的……
外部类
Constructor,Method,Class.forName,newInstance
下面来看如何对上述的类进行反射
首先先看外部类Outer
打印结果
下面简单分析下
我们对类reflect.Outer进行反射,这里使用Outer.class也可以获得Class对象
之前说过使用类字面量不会初始化该类,而Class.forName则会初始化 ,当使用Outer.class时候log如下
顺序改变了,打印的时候Testing..实际是下面这句触发的
这时候加载Outer这个类,然后进行初始化
接下来我们查看了Outer的所有构造器Constructor,并打印出所需要的参数(与普通方法区别开来)
构造器只有一个,参数是String
如何执行这个带有String作为参数的构造器来返回一个Outer实例
我们先取得我们需要的Constructor,然后,Constructor提供了newInstance方法,这样就可以获得Outer实例
最后打印实例,调用了toString函数
如果你尝试调用
则会看到如下异常
java.lang.InstantiationException: reflect.Outer
at java.lang.Class.newInstance0(Class.java:357)
at java.lang.Class.newInstance(Class.java:325)
at reflect.Test.main(Test.java:30)
这是因为Outer没有提供默认构造器
在获得Constructor时其实是有下面两个选择的,至于区别,我们放在Method里说
现在看看如何获得类的方法,顺便看看Declared的作用
不如直接打印出来,这样比较直观
结果如下
调用getMethods时,Outer的方法只打印出了toString,其余结果均为父类Object的公有方法
调用getDeclaredMethods时,则只打印出在Outer中声明定义的方法
他们均打印出了公共的静态方法
所有带Declared和不带Declared的成对的方法都和上面的类似
如何利用反射执行一个方法,下面以void reflect.Outer.privateMethod()为例
首先privateMethod是私有方法,所以为了能得到对应的Method对象,我们需要调用getDeclaredMethod
为了能访问私有方法,我们需要进行setAccessible(true)的设置
然后需要有个对象来执行,我们选择刚才的outerInstance
这时控制台输出
干完活后,恢复其设置setAccessible(false)
下面是静态方法的执行
ps:使用method.invoke(outerInstance, (Object[])null);也能执行,但是不该这样
内部类
isInterface,Field,isAccessible,setAccessible,getModifiers,Modifier.toString()
下面看看内部类的反射
输出
看来反射提供的api功能还是很全的
下面是如何反射静态内部类
也可以使用Class.forName方式,如果StaticInner是不可见的,那么上面的代码则无法编译,下面看看Class.forName
如果你和上面的写法一样,那么很不幸,运行时会得到如下错误
java.lang.ClassNotFoundException: reflect.Outer.StaticInner
at java.net.URLClassLoader$1.run(URLClassLoader.java:217)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:205)
at java.lang.ClassLoader.loadClass(ClassLoader.java:321)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:294)
at java.lang.ClassLoader.loadClass(ClassLoader.java:266)
at java.lang.Class.forName0(Native Method)
at java.lang.Class.forName(Class.java:186)
at reflect.Test.main(Test.java:11)
我们去bin目录下可以发现这样的文件Outer$StaticInner.class
反射代码只需做如下改动
.变成了$
这里newInstance之所以能执行,是因为StaticInner有默认构造器
下面看看StaticInner中生命了哪些变量
结果如下
StaticInner只声明了一个变量,名字为TAG,类型为String
即使是private变量,设置setAccessible(true)之后也能改变其值
普通内部类的反射和上面类似
最后说下匿名内部类
匿名内部类的作用是仅仅使用一次,所以也没有必要进行反射,实际上也很难进行反射
例子中有两个匿名内部类
在bin目录下发现有Outer$1.class和Outer$2.class
getDeclaredClasses发现也没有匿名内部类的信息
结果
只有这三个,包括一个接口
如果非要对匿名内部类进行反射,也不是不可能
下面演示如何反射一个匿名内部类,仅仅是演示,没有任何意义,也不推荐这么做
我们以上面的toString方法里面的内部类做例子
结果如下
下面看看代码都做了什么,依次说明
首先获取Outer$2的Class
然后获取其构造器,查看所需要的参数,我们发现内部匿名类也需要一个外部类的支持
然后我们newInstance生成实例,声明为一个接口,由于要传入外部类,这里我们直接new一个,所以会初始化外部类,打印第2,3句
接下来查看内部类的方法,找到test(),这是第4句打印的结果
最后用实例化好的内部匿名类执行这个方法,所以打印出了最后一句
执行第一个匿名内部类的方法代码简单些,同样不推荐这么做
为了演示反射,这里没有使用System.out.println(o.ti.test());
至此,反射演示结束
由于写本篇blog的时候多次修改代码,所以上面可能有些地方不太一致,如果发现,敬请指正
转贴请保留以下链接
本人blog地址
http://su1216.iteye.com/
http://blog.csdn.net/su1216/
java 运行时类型识别(RTTI) - 2 - 反射
本文将叙述如何运行时查看类信息,其中包括变量,方法,以及通过反射修改变量,执行方法等
包括如何反射匿名内部类及如何执行其方法,但是笔者强烈不建议这么做,这里只是演示反射而已
下面是一个测试类
package reflect; public class Outer { static{ System.out.println("Testing.."); } TestInterface ti = new TestInterface() { public String test() { return "this is ti"; } }; public Outer(String name){ System.out.println("Outer"); } public String toString(){ System.out.println("Outer toString"); return new TestInterface() { public String test() { return "this is a test!"; } }.test(); } @SuppressWarnings("unused") private void privateMethod(){ System.out.println("privateMethod"); } protected void protectedMethod(){ System.out.println("protectedMethod"); } void packageMethod(){ System.out.println("packageMethod"); } public static void staticMethod(){ System.out.println("staticMethod"); } public interface TestInterface { public String test(); } public static class StaticInner { private static final String TAG = "StaticInnerTAG"; public StaticInner(){ System.out.println("StaticInner"); } public String toString(){ System.out.println("StaticInner toString"); return TAG; } } private class Inner{ String name; public Inner(){ System.out.println("Inner"); } public Inner(String name){ System.out.println("reflect.Outer.Inner.Inner(String name)"); this.name = name; } } }
其中包括了普通内部类,静态内部类,内部匿名类,接口等
其中外部类Outer没有默认构造器,String reflect.Outer.Inner.getName()是private的……
外部类
Constructor,Method,Class.forName,newInstance
下面来看如何对上述的类进行反射
首先先看外部类Outer
public static void main(String[] args) { try { Class<?> outer = Class.forName("reflect.Outer"); outer = Outer.class; Constructor<?>[] constructors = outer.getConstructors(); for (Constructor<?> constructor : constructors) { Class<?>[] types = constructor.getParameterTypes(); System.out.println(constructor.getName() + "(" + arrayToString(types) + ")"); } Constructor<?> outerConstructor = outer.getConstructor(String.class); Outer outerInstance = (Outer) outerConstructor.newInstance("a outer"); System.out.println(outerInstance); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (SecurityException e) { e.printStackTrace(); } catch (NoSuchMethodException e) { e.printStackTrace(); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } } public static String arrayToString(Class<?>[] classes){ StringBuilder stringBuilder = new StringBuilder(); for (Class<?> type : classes) { stringBuilder.append(type.getCanonicalName()); stringBuilder.append(","); } if(classes.length > 0){ stringBuilder.deleteCharAt(stringBuilder.length() - 1); } return stringBuilder.toString(); }
打印结果
Testing.. reflect.Outer(java.lang.String) Outer Outer toString this is a test!
下面简单分析下
Class<?> outer = Class.forName("reflect.Outer"); //outer = Outer.class;
我们对类reflect.Outer进行反射,这里使用Outer.class也可以获得Class对象
之前说过使用类字面量不会初始化该类,而Class.forName则会初始化 ,当使用Outer.class时候log如下
reflect.Outer(java.lang.String) Testing.. Outer Outer toString this is a test!
顺序改变了,打印的时候Testing..实际是下面这句触发的
Outer outerInstance = (Outer) outerConstructor.newInstance("a outer");
这时候加载Outer这个类,然后进行初始化
接下来我们查看了Outer的所有构造器Constructor,并打印出所需要的参数(与普通方法区别开来)
构造器只有一个,参数是String
如何执行这个带有String作为参数的构造器来返回一个Outer实例
Constructor<?> outerConstructor = outer.getConstructor(String.class); Outer outerInstance = (Outer) outerConstructor.newInstance("a outer"); System.out.println(outerInstance);
我们先取得我们需要的Constructor,然后,Constructor提供了newInstance方法,这样就可以获得Outer实例
最后打印实例,调用了toString函数
如果你尝试调用
outer.newInstance();
则会看到如下异常
java.lang.InstantiationException: reflect.Outer
at java.lang.Class.newInstance0(Class.java:357)
at java.lang.Class.newInstance(Class.java:325)
at reflect.Test.main(Test.java:30)
这是因为Outer没有提供默认构造器
在获得Constructor时其实是有下面两个选择的,至于区别,我们放在Method里说
outer.getConstructors(); outer.getDeclaredConstructors()
现在看看如何获得类的方法,顺便看看Declared的作用
不如直接打印出来,这样比较直观
Method[] methods = outer.getMethods(); for (Method method : methods) { Class<?>[] types = method.getParameterTypes(); System.out.println(method.getReturnType().getName() + " " + outer.getName() + "." + method.getName() + "(" + arrayToString(types) + ")"); } System.out.println("--------------------------------------"); methods = outer.getDeclaredMethods(); for (Method method : methods) { Class<?>[] types = method.getParameterTypes(); System.out.println(method.getReturnType().getName() + " " + outer.getName() + "." + method.getName() + "(" + arrayToString(types) + ")"); }Class<?> outer = Outer.class;
结果如下
void reflect.Outer.staticMethod() java.lang.String reflect.Outer.toString() void reflect.Outer.wait(long) void reflect.Outer.wait() void reflect.Outer.wait(long,int) boolean reflect.Outer.equals(java.lang.Object) int reflect.Outer.hashCode() java.lang.Class reflect.Outer.getClass() void reflect.Outer.notify() void reflect.Outer.notifyAll() -------------------------------------- void reflect.Outer.privateMethod() void reflect.Outer.protectedMethod() void reflect.Outer.packageMethod() void reflect.Outer.staticMethod() java.lang.String reflect.Outer.toString()
调用getMethods时,Outer的方法只打印出了toString,其余结果均为父类Object的公有方法
调用getDeclaredMethods时,则只打印出在Outer中声明定义的方法
他们均打印出了公共的静态方法
所有带Declared和不带Declared的成对的方法都和上面的类似
如何利用反射执行一个方法,下面以void reflect.Outer.privateMethod()为例
Method method = outer.getDeclaredMethod("privateMethod"); method.setAccessible(true); method.invoke(outerInstance, (Object[])null); method.setAccessible(false);
首先privateMethod是私有方法,所以为了能得到对应的Method对象,我们需要调用getDeclaredMethod
为了能访问私有方法,我们需要进行setAccessible(true)的设置
然后需要有个对象来执行,我们选择刚才的outerInstance
这时控制台输出
privateMethod
干完活后,恢复其设置setAccessible(false)
下面是静态方法的执行
Method method = outer.getDeclaredMethod("staticMethod"); method.setAccessible(true); method.invoke(Outer.class, (Object[])null); method.setAccessible(false);
ps:使用method.invoke(outerInstance, (Object[])null);也能执行,但是不该这样
内部类
isInterface,Field,isAccessible,setAccessible,getModifiers,Modifier.toString()
下面看看内部类的反射
Class<?>[] classes = outer.getDeclaredClasses(); for (Class<?> clazz : classes) { if(clazz.isInterface()){ System.out.println("interface : " + clazz.getName()); }else{ System.out.println("class : " + clazz.getName()); } }
输出
class : reflect.Outer$Inner class : reflect.Outer$StaticInner interface : reflect.Outer$TestInterface
看来反射提供的api功能还是很全的
下面是如何反射静态内部类
try { Class<StaticInner> staticInner = StaticInner.class; StaticInner staticInnerInstance = staticInner.newInstance(); }catch (SecurityException e) { e.printStackTrace(); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); }
也可以使用Class.forName方式,如果StaticInner是不可见的,那么上面的代码则无法编译,下面看看Class.forName
try { Class<StaticInner> staticInner = (Class<StaticInner>) Class.forName("reflect.Outer.StaticInner"); StaticInner staticInnerInstance = staticInner.newInstance(); }catch (SecurityException e) { e.printStackTrace(); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); }
如果你和上面的写法一样,那么很不幸,运行时会得到如下错误
java.lang.ClassNotFoundException: reflect.Outer.StaticInner
at java.net.URLClassLoader$1.run(URLClassLoader.java:217)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:205)
at java.lang.ClassLoader.loadClass(ClassLoader.java:321)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:294)
at java.lang.ClassLoader.loadClass(ClassLoader.java:266)
at java.lang.Class.forName0(Native Method)
at java.lang.Class.forName(Class.java:186)
at reflect.Test.main(Test.java:11)
我们去bin目录下可以发现这样的文件Outer$StaticInner.class
反射代码只需做如下改动
Class<StaticInner> staticInner = (Class<StaticInner>) Class.forName("reflect.Outer$StaticInner");
.变成了$
这里newInstance之所以能执行,是因为StaticInner有默认构造器
下面看看StaticInner中生命了哪些变量
Class<StaticInner> staticInner = StaticInner.class; Field[] fields = staticInner.getDeclaredFields(); for (Field field : fields) { Class<?> type = field.getType(); field.setAccessible(true); System.out.println(Modifier.toString(field.getModifiers()) + " " + type.getName() + " " + field.getName()); } StaticInner StaticInnerInstance = staticInner.newInstance(); Field field = staticInner.getDeclaredField("TAG"); boolean accessible = field.isAccessible(); if(!accessible){ field.setAccessible(true); } System.out.println(field.get(StaticInnerInstance)); field.set(StaticInnerInstance, "TAG"); System.out.println(field.get(StaticInnerInstance)); if(!accessible){ field.setAccessible(false); }
结果如下
private java.lang.String TAG StaticInner StaticInnerTAG TAG
StaticInner只声明了一个变量,名字为TAG,类型为String
即使是private变量,设置setAccessible(true)之后也能改变其值
普通内部类的反射和上面类似
最后说下匿名内部类
匿名内部类的作用是仅仅使用一次,所以也没有必要进行反射,实际上也很难进行反射
例子中有两个匿名内部类
TestInterface ti = new TestInterface() { public String test() { return "this is ti"; } }; public String toString(){ System.out.println("Outer toString"); return new TestInterface() { public String test() { return "this is a test!"; } }.test(); }
在bin目录下发现有Outer$1.class和Outer$2.class
getDeclaredClasses发现也没有匿名内部类的信息
try { Class<Outer> outer = Outer.class; Class<?>[] classes = outer.getDeclaredClasses(); for (Class<?> clazz : classes) { System.out.println(clazz.getName()); } }catch (SecurityException e) { e.printStackTrace(); } catch (IllegalArgumentException e) { e.printStackTrace(); }
结果
reflect.Outer$Inner reflect.Outer$StaticInner reflect.Outer$TestInterface
只有这三个,包括一个接口
如果非要对匿名内部类进行反射,也不是不可能
下面演示如何反射一个匿名内部类,仅仅是演示,没有任何意义,也不推荐这么做
我们以上面的toString方法里面的内部类做例子
try { Class<?> clazz = Class.forName("reflect.Outer$2"); Constructor<?>[] constructors = clazz.getDeclaredConstructors(); constructors[0].setAccessible(true); Class<?>[] types = constructors[0].getParameterTypes(); for (Class<?> type : types) { System.out.println("Parameter Types:" + type.getName()); } TestInterface testInterface = (TestInterface) constructors[0].newInstance(new Outer("")); Method[] methods = clazz.getDeclaredMethods(); for (Method method : methods) { Class<?>[] parameterTypes = method.getParameterTypes(); System.out.println(method.getName() + "(" + arrayToString(parameterTypes) + ")"); } Method method = clazz.getDeclaredMethod("test"); String string = (String)method.invoke(testInterface); System.out.println(string); }catch (SecurityException e) { e.printStackTrace(); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } catch (NoSuchMethodException e) { e.printStackTrace(); }
结果如下
Parameter Types:reflect.Outer Testing.. Outer test() this is a test!
下面看看代码都做了什么,依次说明
首先获取Outer$2的Class
然后获取其构造器,查看所需要的参数,我们发现内部匿名类也需要一个外部类的支持
然后我们newInstance生成实例,声明为一个接口,由于要传入外部类,这里我们直接new一个,所以会初始化外部类,打印第2,3句
接下来查看内部类的方法,找到test(),这是第4句打印的结果
最后用实例化好的内部匿名类执行这个方法,所以打印出了最后一句
执行第一个匿名内部类的方法代码简单些,同样不推荐这么做
try { Class<Outer> clazz = Outer.class; Outer o = new Outer(""); //System.out.println(o.ti.test()); Field field = clazz.getDeclaredField("ti"); TestInterface testInterface = (TestInterface) field.get(o); System.out.println(testInterface.test()); }catch (SecurityException e) { e.printStackTrace(); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (NoSuchFieldException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); }
为了演示反射,这里没有使用System.out.println(o.ti.test());
至此,反射演示结束
由于写本篇blog的时候多次修改代码,所以上面可能有些地方不太一致,如果发现,敬请指正
转贴请保留以下链接
本人blog地址
http://su1216.iteye.com/
http://blog.csdn.net/su1216/
相关文章推荐
- Java RTTI 运行时类型识别 和反射
- java 运行时类型识别(RTTI) - 2 - 反射
- 【Java进阶】运行时类型识别RTTI的作用
- Java的反射与RTTI(运行时类型信息)的区别
- Java基础之RTTI 运行时类型识别
- JAVA基础教程6:运行时类型识别(RTTI)
- Java&&RTTI(运行时类型识别)
- JAVA的运行时类型识别(RTTI)
- java 运行时类型识别(RTTI) - 1 - Class与instanceof
- 举例讲解Java的RTTI运行时类型识别机制
- Java进阶教程之运行时类型识别RTTI机制
- Java基础之RTTI 运行时类型识别
- java 运行时类型识别(RTTI) - 1 - Class与instanceof
- RTTI(运行时类型识别)问题
- RTTI运行阶段类型识别(Runtime Type Identification)
- 【转载】C/C++杂记:运行时类型识别(RTTI)与动态类型转换原理
- Java进阶(四)Java反射TypeToken解决泛型运行时类型擦除问题
- RTTI 运行阶段类型识别
- 谈谈Java中的类型识别RTTI
- RTTI运行时类型识别