测试java反射机制

首先写一个类 

public class MyObject { 
public int a; 
public int b; 

public MyObject() { 
} 
private MyObject(int a) { 

} 
public MyObject(int a, int b) { 
this.a = a; 
this.b = b; 
} 
public int sum(){ 
return a+b; 
} 
public int minus(){ 
return a-b; 
} 
public int multiply(){ 
return a*b; 
} 
public int divide(){ 
return a/b; 
} 
public void voidGet(){ 

} 
public int divide(int c,int d){ 
return c/d; 
} 

} 

测试如下 

//获取类 
System.out.println("--------获取类-------------------------"); 
Class cls=Class.forName("reflect.MyObject"); 
System.out.println(cls); 
System.out.println(MyObject.class); 
System.out.println(cls.getClass()); 
//测试获取类的方法 
Method []method=cls.getDeclaredMethods(); 
for(int i=0;i<method.length;i++){ 
Method m=method[i]; 
Class pclass[]=m.getParameterTypes(); 
System.out.println("参数个数："+pclass.length);
for(int j=0;j<pclass.length;j++){ 
System.out.println("参数："+pclass[j].toString());
} 

System.out.println("方法名："+m.getName()); 
System.out.println("修饰符："+m.getModifiers()); 
System.out.println("返回值："+m.getReturnType()); 
} 
//取得类的构造函数 
System.out.println("--------取得类的构造函数-------------------------"); 
Constructor cor[]=cls.getDeclaredConstructors(); 
for(int i=0;i<cor.length;i++){ 
Constructor co=cor[i]; 
System.out.println("方法名："+co.getName()); 
System.out.println("修饰符："+co.getModifiers()); 
//参数列表 
Class params[]=co.getParameterTypes(); 
for(int j=0;j<params.length;j++){ 
System.out.println("参数："+params[j].toString());
} 
} 
//测试获取字段 
System.out.println("--------测试获取字段-------------------------"); 
Field []field=cls.getDeclaredFields(); 
for(int i=0;i<field.length;i++){ 
Field m=field[i]; 
System.out.println("变量名："+m.getName()); 
System.out.println("修饰符："+m.getModifiers()); 
System.out.println("变量类型："+m.getType()); 
} 

//参数类型 
Class ptype[]=new Class[2]; 
ptype[0]=int.class; 
ptype[1]=int.class; 
try { 
Constructor corr=cls.getConstructor(ptype); 
try { 
Object obj=corr.newInstance(6,3); 

//改变字段的值 
try { 
Field fielda=cls.getField("a"); 
System.out.println("改变前：a="+fielda.get(obj)); 
fielda.set(obj, 100); 
System.out.println("改变后：a="+fielda.get(obj)); 
} catch (SecurityException e) { 
// TODO Auto-generated catch block 
e.printStackTrace(); 
} catch (NoSuchFieldException e) { 
// TODO Auto-generated catch block 
e.printStackTrace(); 
} 
//执行方法 
Method me=cls.getMethod("sum"); 
Object returnvalue=me.invoke(obj); 
System.out.println("加="+returnvalue); 
me=cls.getMethod("minus"); 
returnvalue=me.invoke(obj); 
System.out.println("减="+returnvalue); 
me=cls.getMethod("multiply"); 
returnvalue=me.invoke(obj); 
System.out.println("乘="+returnvalue); 
me=cls.getMethod("divide"); 
returnvalue=me.invoke(obj); 
System.out.println("除="+returnvalue); 
me=cls.getMethod("voidGet"); 
returnvalue=me.invoke(obj); 
System.out.println("无返回值="+returnvalue); 
me=cls.getMethod("divide",new Class[]{int.class,int.class}); 
returnvalue=me.invoke(obj,new Integer[]{6,3}); 
System.out.println("有参数的私有="+returnvalue); 

//数组 
Class str=Class.forName("java.lang.String"); 
Object arr=Array.newInstance(str, 10); 
Array.set(arr, 5, "this is a test "); 
Array.set(arr, 0, "this is a test "); 
String str5=(String)Array.get(arr, 5); 
String str0=(String)Array.get(arr, 0); 
//String str10=(String)Array.get(arr, 10);//数组越界 
System.out.println("数组元素="+str5); 
System.out.println("数组元素="+str0); 
//System.out.println("数组元素="+str10); 

} catch (IllegalArgumentException e) { 
// TODO Auto-generated catch block 
e.printStackTrace(); 
} catch (InstantiationException e) { 
// TODO Auto-generated catch block 
e.printStackTrace(); 
} catch (IllegalAccessException e) { 
// TODO Auto-generated catch block 
e.printStackTrace(); 
} catch (InvocationTargetException e) { 
// TODO Auto-generated catch block 
e.printStackTrace(); 
} 
//调用默认构造函数 
corr=cls.getConstructor(); 
try { 
Object obj1=corr.newInstance(); 
} catch (IllegalArgumentException e) { 
// TODO Auto-generated catch block 
e.printStackTrace(); 
} catch (InstantiationException e) { 
// TODO Auto-generated catch block 
e.printStackTrace(); 
} catch (IllegalAccessException e) { 
// TODO Auto-generated catch block 
e.printStackTrace(); 
} catch (InvocationTargetException e) { 
// TODO Auto-generated catch block 
e.printStackTrace(); 
} 

} catch (SecurityException e) { 
// TODO Auto-generated catch block 
e.printStackTrace(); 
} catch (NoSuchMethodException e) { 
// TODO Auto-generated catch block 
e.printStackTrace(); 
} 




} catch (ClassNotFoundException e) { 
// TODO Auto-generated catch block 
e.printStackTrace(); 
} 



测试结果如下： 




--------获取类------------------------- 
class reflect.MyObject 
class reflect.MyObject 
class java.lang.Class 
参数个数：0 
方法名：sum 
修饰符：1 
返回值：int 
参数个数：0 
方法名：minus 
修饰符：1 
返回值：int 
参数个数：0 
方法名：voidGet 
修饰符：1 
返回值：void 
参数个数：2 
参数：int 
参数：int 
方法名：divide 
修饰符：1 
返回值：int 
参数个数：0 
方法名：divide 
修饰符：1 
返回值：int 
参数个数：0 
方法名：multiply 
修饰符：1 
返回值：int 
--------取得类的构造函数------------------------- 
方法名：reflect.MyObject 
修饰符：1 
方法名：reflect.MyObject 
修饰符：1 
参数：int 
参数：int 
方法名：reflect.MyObject 
修饰符：2 
参数：int 
--------测试获取字段------------------------- 
变量名：a 
修饰符：1 
变量类型：int 
变量名：b 
修饰符：1 
变量类型：int 
改变前：a=6 
改变后：a=100 
加=103 
减=97 
乘=300 
除=33 
无返回值=null 
有参数的私有=2 
数组元素=this is a test 
数组元素=this is a test