本文将叙述如何运行时查看类信息,其中包括变量,方法,以及通过反射修改变量,执行方法等
包括如何反射匿名内部类及如何执行其方法,但是笔者强烈不建议这么做,这里只是演示反射而已
下面是一个测试类
Java代码
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
Java代码
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();
}
打印结果
Java代码
Testing..
reflect.Outer(java.lang.String)
Outer
Outer toString
this is a test!
下面简单分析下
Java代码
Class> outer = Class.forName("reflect.Outer");
//outer = Outer.class;
我们对类reflect.Outer进行反射,这里使用Outer.class也可以获得Class对象
之前说过使用类字面量不会初始化该类,而Class.forName则会初始化,当使用Outer.class时候log如下
Java代码
reflect.Outer(java.lang.String)
Testing..
Outer
Outer toString
this is a test!
顺序改变了,打印的时候Testing..实际是下面这句触发的
Java代码
Outer outerInstance = (Outer) outerConstructor.newInstance("a outer");
这时候加载Outer这个类,然后进行初始化
接下来我们查看了Outer的所有构造器Constructor,并打印出所需要的参数(与普通方法区别开来)
构造器只有一个,参数是String
如何执行这个带有String作为参数的构造器来返回一个Outer实例
Java代码
Constructor> outerConstructor = outer.getConstructor(String.class);
Outer outerInstance = (Outer) outerConstructor.newInstance("a outer");
System.out.println(outerInstance);
我们先取得我们需要的Constructor,然后,Constructor提供了newInstance方法,这样就可以获得Outer实例
最后打印实例,调用了toString函数
如果你尝试调用
Java代码
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里说
Java代码
outer.getConstructors();
outer.getDeclaredConstructors()
现在看看如何获得类的方法,顺便看看Declared的作用
不如直接打印出来,这样比较直观
Java代码
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;
结果如下
Java代码
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()为例
Java代码
Method method = outer.getDeclaredMethod("privateMethod");
method.setAccessible(true);
method.invoke(outerInstance, (Object[])null);
method.setAccessible(false);
首先privateMethod是私有方法,所以为了能得到对应的Method对象,我们需要调用getDeclaredMethod
为了能访问私有方法,我们需要进行setAccessible(true)的设置
然后需要有个对象来执行,我们选择刚才的outerInstance
这时控制台输出
Java代码
privateMethod
干完活后,恢复其设置setAccessible(false)
下面是静态方法的执行
Java代码
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()
下面看看内部类的反射
Java代码
Class>[] classes = outer.getDeclaredClasses();
for (Class> clazz : classes) {
if(clazz.isInterface()){
System.out.println("interface : " + clazz.getName());
}else{
System.out.println("class : " + clazz.getName());
}
}
输出
Java代码
class : reflect.Outer$Inner
class : reflect.Outer$StaticInner
interface : reflect.Outer$TestInterface
看来反射提供的api功能还是很全的
下面是如何反射静态内部类
Java代码
try {
Class 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
Java代码
try {
Class staticInner = (Class) 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
反射代码只需做如下改动
Java代码
Class staticInner = (Class) Class.forName("reflect.Outer$StaticInner");
.变成了$
这里newInstance之所以能执行,是因为StaticInner有默认构造器
下面看看StaticInner中生命了哪些变量
Java代码
Class 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);
}
结果如下
Java代码
private java.lang.String TAG
StaticInner
StaticInnerTAG
TAG
StaticInner只声明了一个变量,名字为TAG,类型为String
即使是private变量,设置setAccessible(true)之后也能改变其值
普通内部类的反射和上面类似
最后说下匿名内部类
匿名内部类的作用是仅仅使用一次,所以也没有必要进行反射,实际上也很难进行反射
例子中有两个匿名内部类
Java代码
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发现也没有匿名内部类的信息
Java代码
try {
Class 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();
}
结果
Java代码
reflect.Outer$Inner
reflect.Outer$StaticInner
reflect.Outer$TestInterface
只有这三个,包括一个接口
如果非要对匿名内部类进行反射,也不是不可能
下面演示如何反射一个匿名内部类,仅仅是演示,没有任何意义,也不推荐这么做
我们以上面的toString方法里面的内部类做例子
Java代码
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();
}
结果如下
Java代码
Parameter Types:reflect.Outer
Testing..
Outer
test()
this is a test!
下面看看代码都做了什么,依次说明
首先获取Outer$2的Class
然后获取其构造器,查看所需要的参数,我们发现内部匿名类也需要一个外部类的支持
然后我们newInstance生成实例,声明为一个接口,由于要传入外部类,这里我们直接new一个,所以会初始化外部类,打印第2,3句
接下来查看内部类的方法,找到test(),这是第4句打印的结果
最后用实例化好的内部匿名类执行这个方法,所以打印出了最后一句
执行第一个匿名内部类的方法代码简单些,同样不推荐这么做
Java代码
try {
Class 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地址