Java反射机制深入理解
Java反射机制深入理解
一.概念
反射就是把Java的各种成分映射成相应的Java类。
Class类的构造方法是private，由JVM创建。
反射是java语言的一个特性，它允程序在运行时（注意不是编译的时候）来进行自我检查并且对内部的成员进行操作。例如它允许一个java的类获取他所有的成员变量和方法并且显示出来。Java的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C或者C++中就没有办法在程序中获得函数定义相关的信息。（来自Sun）
JavaBean是reflection的实际应用之一，它能让一些工具可视化的操作软件组件。这些工具通过reflection动态的载入并取得Java组件(类)的属性。
反射是从1.2就有的，后面的三大框架都会用到反射机制,涉及到类”Class”,无法直接newCLass()，其对象是内存里的一份字节码.
Class类的实例表示正在运行的Java应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为Class对象的一个类，所有具有相同元素类型和维数的数组都共享该Class对象。基本的Java类型（boolean、byte、char、short、int、long、float和double）和关键字void也表示为Class对象。Class没有公共构造方法。Class对象是在加载类时由Java虚拟机以及通过调用类加载器中的defineClass方法自动构造的。
Personp1=newPerson();
//下面的这三种方式都可以得到字节码
CLassc1=Date.class();
p1.getClass();
//若存在则加载，否则新建,往往使用第三种,类的名字在写源程序时不需要知道，到运行时再传递过来
Class.forName("java.lang.String");
CLass.forName()字节码已经加载到java虚拟机中，去得到字节码；java虚拟机中还没有生成字节码用类加载器进行加载，加载的字节码缓冲到虚拟机中。
考虑下面这个简单的例子，让我们看看reflection是如何工作的。
importjava.lang.reflect.*;
publicclassDumpMethods{
publicstaticvoidmain(Stringargs[]){
try{
Classc=Class.forName("java.util.Stack");
Methodm[]=c.getDeclaredMethods();
for(inti=0;i
publicsynchronizedjava.lang.Objectjava.util.Stack.pop()
publicjava.lang.Objectjava.util.Stack.push(java.lang.Object)
publicbooleanjava.util.Stack.empty()
publicsynchronizedjava.lang.Objectjava.util.Stack.peek()
publicsynchronizedintjava.util.Stack.search(java.lang.Object)
这样就列出了java.util.Stack类的各方法名以及它们的限制符和返回类型。这个程序使用Class.forName载入指定的类，然后调用getDeclaredMethods来获取这个类中定义了的方法列表。java.lang.reflect.Methods是用来描述某个类中单个方法的一个类。
以下示例使用Class对象来显示对象的类名：
voidprintClassName(Objectobj){
System.out.println("Theclassof"+obj+
"is"+obj.getClass().getName());
}
还可以使用一个类字面值（JLSSection15.8.2）来获取指定类型（或void）的Class对象。例如：
System.out.println("ThenameofclassFoois:"+Foo.class.getName());
在没有对象实例的时候，主要有两种办法。
//获得类类型的两种方式
Classcls1=Role.class;
Classcls2=Class.forName("yui.Role");
注意第二种方式中，forName中的参数一定是完整的类名（包名+类名），并且这个方法需要捕获异常。现在得到cls1就可以创建一个Role类的实例了，利用Class的newInstance方法相当于调用类的默认的构造器。
Objecto=cls1.newInstance();
//创建一个实例
//Objecto1=newRole();//与上面的方法等价
二.常用方法
1.isPrimitive(判断是否是基本类型的字节码)
publicclassTestReflect{
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
Stringstr="abc";
Classcls1=str.getClass();
Classcls2=String.class;
Classcls3=null;//必须要加上null
try{
cls3=Class.forName("java.lang.String");
}catch(ClassNotFoundExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
System.out.println(cls1==cls2);
System.out.println(cls1==cls3);
System.out.println(cls1.isPrimitive());
System.out.println(int.class.isPrimitive());//判定指定的Class对象是否表示一个基本类型。
System.out.println(int.class==Integer.class);
System.out.println(int.class==Integer.TYPE);
System.out.println(int[].class.isPrimitive());
System.out.println(int[].class.isArray());
}
}
/*
*true
true
false
true
false
true
false
true
*/
*/
2.getConstructor和getConstructors()
java中构造方法没有先后顺序，通过类型和参数个数区分。
/**
*Java学习交流QQ群：589809992我们一起学Java！
*/
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsSecurityException,NoSuchMethodException{
//TODOAuto-generatedmethodstub
Stringstr="abc";
System.out.println(String.class.getConstructor(StringBuffer.class));
}
}
3.Filed类代表某一类中的一个成员变量。
importjava.lang.reflect.Field;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsSecurityException,NoSuchMethodException,NoSuchFieldException,IllegalArgumentException,Exception{
ReflectPointerrp1=newReflectPointer(3,4);
Fieldfieldx=rp1.getClass().getField("x");//必须是x或者y
System.out.println(fieldx.get(rp1));
/*
*private的成员变量必须使用getDeclaredField，并setAccessible(true),否则看得到拿不到
*/
Fieldfieldy=rp1.getClass().getDeclaredField("y");
fieldy.setAccessible(true);//暴力反射
System.out.println(fieldy.get(rp1));
}
}
classReflectPointer{
publicintx=0;
privateinty=0;
publicReflectPointer(intx,inty){//alt+shift+s相当于右键source
super();
//TODOAuto-generatedconstructorstub
this.x=x;
this.y=y;
}
}
三.典型例题
1.将所有String类型的成员变量里的b改成a。
importjava.lang.reflect.Field;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsSecurityException,NoSuchMethodException,NoSuchFieldException,IllegalArgumentException,Exception{
ReflectPointerrp1=newReflectPointer(3,4);
changeBtoA(rp1);
System.out.println(rp1);
}
privatestaticvoidchangeBtoA(Objectobj)throwsRuntimeException,Exception{
Field[]fields=obj.getClass().getFields();
for(Fieldfield:fields){
//if(field.getType().equals(String.class))
//由于字节码只有一份,用equals语义不准确
if(field.getType()==String.class){
StringoldValue=(String)field.get(obj);
StringnewValue=oldValue.replace('b','a');
field.set(obj,newValue);
}
}
}
}
classReflectPointer{
privateintx=0;
publicinty=0;
publicStringstr1="ball";
publicStringstr2="basketball";
publicStringstr3="itcat";
publicReflectPointer(intx,inty){//alt+shift+s相当于右键source
super();
//TODOAuto-generatedconstructorstub
this.x=x;
this.y=y;
}
@Override
publicStringtoString(){
return"ReflectPointer[str1="+str1+",str2="+str2+",str3="
+str3+"]";
}
}
2.写一个程序根据用户提供的类名，调用该类的里的main方法。
为什么要用反射的方式呢？
importjava.lang.reflect.Field;
importjava.lang.reflect.Method;
/**
*Java学习交流QQ群：589809992我们一起学Java！
*/
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsSecurityException,NoSuchMethodException,NoSuchFieldException,IllegalArgumentException,Exception{
Stringstr=args[0];
/*
*这样会数组角标越界，因为压根没有这个字符数组
*需要右键在runas-configurations-arguments里输入b.Inter（完整类名）
*
*/
Methodm=Class.forName(str).getMethod("main",String[].class);
//下面这两种方式都可以,main方法需要一个参数
m.invoke(null,newObject[]{newString[]{"111","222","333"}});
m.invoke(null,(Object)newString[]{"111","222","333"});//这个可以说明，数组也是Object
/*
*m.invoke(null,newString[]{"111","222","333"})
*上面的不可以,因为java会自动拆包
*/
}
}
classInter{
publicstaticvoidmain(String[]args){
for(Objectobj:args){
System.out.println(obj);
}
}
}
3.模拟instanceof操作符
classS{
}
publicclassIsInstance{
publicstaticvoidmain(Stringargs[]){
try{
Classcls=Class.forName("S");
booleanb1=cls.isInstance(newInteger(37));
System.out.println(b1);
booleanb2=cls.isInstance(newS());
System.out.println(b2);
}
catch(Throwablee){
System.err.println(e);
}
}
}
在这个例子中创建了一个S类的Class对象，然后检查一些对象是否是S的实例。Integer(37)不是，但newS()是。
四.Method类
代表类（不是对象）中的某一方法。
importjava.lang.reflect.Field;
importjava.lang.reflect.Method;
/*
*人在黑板上画圆，涉及三个对象,画圆需要圆心和半径，但是是私有的，画圆的方法
*分配给人不合适。Java学习交流QQ群：589809992我们一起学Java！
*
*司机踩刹车，司机只是给列车发出指令，刹车的动作还需要列车去完成。
*
*面试经常考面向对象的设计，比如人关门，人只是去推门。
*
*这就是专家模式：谁拥有数据，谁就是专家,方法就分配给谁
*/
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsSecurityException,NoSuchMethodException,NoSuchFieldException,IllegalArgumentException,Exception{
Stringstr="shfsfs";
//包开头是com表示是sun内部用的，java打头的才是用户的
MethodmtCharAt=String.class.getMethod("charAt",int.class);
Objectch=mtCharAt.invoke(str,1);//若第一个参数是null，则肯定是静态方法
System.out.println(ch);
System.out.println(mtCharAt.invoke(str,newObject[]{2}));//1.4语法
}
}
五.数组的反射
Array工具类用于完成数组的反射操作。
同类型同纬度有相同的字节码。
int.class和Integer.class不是同一份字节码，Integer.TYPE，TYPE代表包装类对应的基本类的字节码int.class==Integer.TYPE
importjava.util.Arrays;
/*
*从这个例子看出即便字节码相同但是对象也不一定相同,根本不是一回事
*
*/
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsSecurityException,NoSuchMethodException,NoSuchFieldException,IllegalArgumentException,Exception{
int[]a=newint[3];
int[]b=newint[]{4,5,5};//直接赋值后不可以指定长度，否则ＣＥ
int[][]c=newint[3][2];
String[]d=newString[]{"jjj","kkkk"};
System.out.println(a==b);//false
System.out.println(a.getClass()==b.getClass());//true
//System.out.println(a.getClass()==d.getClass());//比较字节码a和cd也没法比
System.out.println(a.getClass());//输出class[I
System.out.println(a.getClass().getName());//输出[I,中括号表示数组，I表示整数
System.out.println(a.getClass().getSuperclass());//输出classjava.lang.Object
System.out.println(d.getClass().getSuperclass());//输出classjava.lang.Object
//由于父类都是Object,下面都是可以的
Objectobj1=a;//不可是Object[]
Objectobj2=b;
Object[]obj3=c;//基本类型的一位数组只可以当做Object，非得还可以当做Object[]
Objectobj4=d;
//注意asList处理int[]和String[]的区别
System.out.println(Arrays.asList(b));//1.4没有可变参数，使用的是数组,[[I@1bc4459]
System.out.println(Arrays.asList(d));//[jjj,kkkk]
}
}
六.结束语
以上就是反射机制的简单的使用，显然学过spring的朋友一定明白了，为什么可以通过配置文件就可以让我们获得指定的方法和变量，在我们创建对象的时候都是通过传进string实现的，就好像你需要什么，我们去为你生产，还有我们一直在用Object,这就说明java语言的动态特性，依赖性大大的降低了。
如有疑问请留言或者到本站社区交流讨论，感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！