Java系列笔记(2) - Java RTTI和反射机制
本文内容纲要：
目录
- 前言
- 传统的RTTI
- 反射
- 反射的实现方式
- 反射的性能
- 反射与设计模式
前言
并不是所有的Class都能在编译时明确，因此在某些情况下需要在运行时再发现和确定类型信息（比如：基于构建编程，），这就是RTTI（RuntimeTypeInformation，运行时类型信息）。
在java中，有两种RTTI的方式，一种是传统的，即假设在编译时已经知道了所有的类型；还有一种，是利用反射机制，在运行时再尝试确定类型信息。
本文主要讲反射方式实现的RTTI，建议在阅读本文之前，先了解类的加载机制（参考我的博客：Java系列笔记(1)-Java类加载与初始化）。
在本文中，将共同使用下面的玩具类Toy，该类中定义了公有、私有方法，变量，构造方法，父类、父接口等：
packagemyblog.rtti;
/**
*@projectMyBlog
*@create2013年6月28日下午4:42:46
*@version1.0.0
*@author张广
*/
publicinterfaceIToy{
publicStringplayToy(Stringplayer)throwsException;
}
packagemyblog.rtti;
publicclassAbstractToyimplementsIToy{
@Override
publicStringplayToy(Stringplayer)throwsException{
System.out.println(player+"playsabstracttoy");
return"";
}
}
packagemyblog.rtti;
publicclassToyextendsAbstractToy{
privateStringname;
publicStringcolor;
protectedintsize;
publicstaticfinalintprice=10;
static{
System.out.println("Loading");
}
publicToy(){//构造方法一定要声明为public类型，不然用getConstructors无法得到
System.out.println("Initialing");
setName("myToy");
color="red";
size=5;
}
publicToy(Stringname,Stringcolor,intsize){
this.setName(name);
this.color=color;
this.size=size;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
@Override
publicStringplayToy(Stringplayer)throwsException{
Stringmsg=buildMsg(player);
System.out.println(msg);
returnmsg;
}
privateStringbuildMsg(Stringplayer){
Stringmsg=player+"plays"+name;
returnmsg;
}
}
传统的RTTI
严格的说，反射也是一种形式的RTTI，不过，一般的文档资料中把RTTI和反射分开，因为一般的，大家认为RTTI指的是传统的RTTI，通过继承和多态来实现，在运行时通过调用超类的方法来实现具体的功能（超类会自动实例化为子类，或使用instanceof）。
传统的RTTI有3种实现方式：
- 向上转型或向下转型（upcastinganddowncasting），在java中，向下转型（父类转成子类）需要强制类型转换
- Class对象（用了Class对象，不代表就是反射，如果只是用Class对象cast成指定的类，那就还是传统的RTTI）
- instanceof或isInstance()
传统的RTTI与反射最主要的区别，在于RTTI在编译期需要.class文件，而反射不需要。传统的RTTI使用转型或Instance形式实现，但都需要指定要转型的类型，比如：
publicvoidrtti(Objectobj){
Toytoy=Toy(obj);
//Toytoy=Class.forName("myblog.rtti.Toy")
//objinstanceofToy
}
注意其中的obj虽然是被转型了，但在编译期，就需要知道要转成的类型Toy，也就是需要Toy的.class文件。
相对的，反射完全在运行时在通过Class类来确定类型，不需要提前加载Toy的.class文件。
反射
那到底什么是反射（Reflection）呢？反射有时候也被称为内省（Introspection），事实上，反射，就是一种内省的方式，Java不允许在运行时改变程序结构或类型变量的结构，但它允许在运行时去探知、加载、调用在编译期完全未知的class，可以在运行时加载该class，生成实例对象（instanceobject），调用method，或对field赋值。这种类似于“看透”了class的特性被称为反射（Reflection），我们可以将反射直接理解为：可以看到自己在水中的倒影，这种操作与直接操作源代码效果相同，但灵活性高得多。
关于Java的反射API，没必要去记忆，可以在任何JDKAPI中查询即可：
Class类：http://www.ostools.net/uploads/apidocs/jdk-zh/java/lang/Class.html
reflect包：http://www.ostools.net/uploads/apidocs/jdk-zh/java/lang/reflect/package-summary.html
反射的实现方式
packagemyblog.rtti;
importjava.lang.reflect.Array;
importjava.lang.reflect.Constructor;
importjava.lang.reflect.Field;
importjava.lang.reflect.InvocationTargetException;
importjava.lang.reflect.Method;
importjava.lang.reflect.Modifier;
/**
*@projectMyBlog
*@create2013年6月28日下午3:00:33
*@version1.0.0
*@author张广
*/
publicclassToyReflection{
publicstaticvoidprintInfo(Stringinfo,Objectobj){
if(obj.getClass().isArray()){
System.out.println(info+":");
intlength=Array.getLength(obj);
System.out.println("ArraySize:"+length);
for(inti=0;i<length;i++){
System.out.print("Array["+i+"]:"+Array.get(obj,i)+",");
}
if(length!=0)
System.out.println();
}
System.out.println(info+":"+obj.toString());
}
publicstaticvoidmain(String[]args){
try{
//获得类对象
Class<?>c=Class.forName("myblog.rtti.Toy");
printInfo("获得类对象",c);
//获得超类
Class<?>superClass=c.getSuperclass();
printInfo("获得超类",superClass);
//获得所有父接口
Class<?>[]interfaces=c.getInterfaces();
printInfo("获得所有父接口",interfaces);
//实例化
Toytoy=(Toy)c.newInstance();
printInfo("实例化",toy);
//获得访问属性为public的构造方法
Constructor<?>[]constructors=c.getConstructors();
printInfo("获得构造方法",constructors);
//获得指定参数的构造方法
Constructor<?>constructor=c.getDeclaredConstructor(String.class,String.class,int.class);
printInfo("获得指定构造方法",constructor);
//获得方法，getMethod只能获得public方法，包括父类和接口继承的方法
Methodmethod=c.getMethod("playToy",String.class);
printInfo("获得公有方法",method);
//调用方法
method.invoke(toy,"张三");
//获得修饰符，包括private/public/protect,static
Stringmodifier=Modifier.toString(method.getModifiers());
printInfo("获得修饰符",modifier);
//获得参数类型
Class<?>[]paramTypes=method.getParameterTypes();
printInfo("获得参数类型",paramTypes);
//获得返回值类型
Class<?>returnType=method.getReturnType();
printInfo("获得返回值类型",returnType);
//获得异常类型
Class<?>[]excepTypes=method.getExceptionTypes();
printInfo("获得异常类型",excepTypes);
//调用私有方法，getDeclaredMethod获得类自身的方法，包括public,protect,private方法
Methodmethod2=c.getDeclaredMethod("buildMsg",String.class);
method2.setAccessible(true);
Stringresult=(String)method2.invoke(toy,"李四");
printInfo("获得私有方法",result);
//获得全部属性
Field[]fields=c.getFields();
printInfo("获得全部属性",fields);
//获得类自身定义的指定属性
Fieldfield=c.getDeclaredField("name");
printInfo("获得自身属性",field);
//获得类及其父类，父接口定义的public属性
Fieldfield2=c.getField("color");
printInfo("获得公有属性",field2);
//获得权限修饰符，包括private/public/protect,static,final
StringfieldModifier=Modifier.toString(field.getModifiers());
printInfo("获得权限修饰符",fieldModifier);
//操作数组
int[]exampleArray={1,2,3,4,5};
//获得数组类型
Class<?>componentType=exampleArray.getClass().getComponentType();
printInfo("数组类型",componentType.getName());
//获得长度
printInfo("数组长度",Array.getLength(exampleArray));
//获得指定元素
printInfo("获得数组元素",Array.get(exampleArray,2));
//修改指定元素
Array.set(exampleArray,2,6);
printInfo("修改数组元素",exampleArray);
//获得当前的类加载器
printInfo("获得当前类加载器",toy.getClass().getClassLoader().getClass().getName());
}catch(ClassNotFoundExceptione){
e.printStackTrace();
}catch(InstantiationExceptione){
e.printStackTrace();
}catch(IllegalAccessExceptione){
e.printStackTrace();
}catch(SecurityExceptione){
e.printStackTrace();
}catch(NoSuchMethodExceptione){
e.printStackTrace();
}catch(IllegalArgumentExceptione){
e.printStackTrace();
}catch(InvocationTargetExceptione){
e.printStackTrace();
}catch(NoSuchFieldExceptione){
e.printStackTrace();
}
}
}
通过上面的代码，可以清晰的理解如何“在水中看到自己”，不过需要注意的有几点：
1，在java的反射机制中，getDeclaredMethod得到的是全部方法，getMethod得到的是公有方法；
2，反射机制的setAccessible可能会破坏封装性，可以任意访问私有方法和私有变量；
3，setAccessible并不是将private改为public，事实上，public方法的accessible属性也是false的，setAccessible只是取消了安全访问控制检查，所以通过设置setAccessible，可以跳过访问控制检查，执行的效率也比较高。参考：http://blog.csdn.net/devilkin64/article/details/7766792
反射的性能
反射机制给予Java开发很大的灵活性，但反射机制本身也有缺点，代表性的缺陷就是反射的性能，一般来说，通过反射调用方法的效率比直接调用的效率要至少慢一倍以上。
关于性能的问题，可以参考这篇博客http://blog.csdn.net/l_serein/article/details/6219897
反射与设计模式
反射的一个很重要的作用，就是在设计模式中的应用，包括在工厂模式和代理模式中的应用。关于这一方面，我会在后续的文章中介绍，有兴趣的朋友也先可以参考这篇文章http://www.cnblogs.com/rollenholt/archive/2011/09/02/2163758.html中关于动态代理模式实现方法的文章。
参考资料
JAVA编程思想，第14章
Java-RTTI与反射机制--详细：http://blog.csdn.net/dahaizisheng/article/details/1762327
Java反射详解：http://www.cnblogs.com/rollenholt/archive/2011/09/02/2163758.html
RTTI和反射机制：http://blog.sina.com.cn/s/blog_5ea2d6840100v9bu.html
Java中的RTTI和反射机制：http://blog.csdn.net/a81895898/article/details/8457623
Java反射性能测试：http://blog.csdn.net/l_serein/article/details/6219897
本文内容总结：
原文链接：https://www.cnblogs.com/zhguang/p/3091378.html