所有说明都在注释中
先是测试反射的类
public class simple
{
public String s="aa";
private String s1="cc";
public void a1(int i)
{
System.out.println("带int参的方法");
}
public void a2(String i)
{
System.out.println("带String的方法");
}
public void simple()
{
System.out.println("这是构造方法");
}
public int a3(int i)
{
return i;
}
private void a4()
{
System.out.println("私有方法");
}
public static void main(String[] args)
{
System.out.println("主方法");
}
}
然后用反射来获取该方法的方法,域,该有构造器
package Main;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class Test {
//用junit测试该方法,可以运行单个方法
@org.junit.Test
public void test() throws NoSuchMethodException, SecurityException {
try {
//后面类名要以 包名加类名的方式
Class cl=Class.forName("Main.simple");
//用getModifiers方法确定该类的修饰符
String modifiers=Modifier.toString(cl.getModifiers());
System.out.println(modifiers);
//返回1 用该方法以整数形式返回修饰符
Integer a=cl.getModifiers();
System.out.println(a);
//获得类名
String name=cl.getName();
System.out.println(name);
//返回类型名称的字符串
String retype=cl.getTypeName();
System.out.println(retype);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
}
}
//反射方法
@org.junit.Test
public void test2()
{
try {
Class cl = Class.forName("Main.simple");
Method method=cl.getMethod("a1",int.class);
System.out.println(method);
/*用该方法调用simple构造器初始化实例
Constructor cll=cl.getConstructor(null);
simple s=(simple)cll.newInstance(null);
System.out.println(s.s);*/
//实例化对象来调用方法,调用方法要指定实例
simple s=new simple();
method.invoke(s,1);
//获得private的方法
//Method mothod2=cl.getDeclaredMethod("simple",null);
//getMethod(“方法名”,带的参数类型)
//获取该构造方法
Method mothod2=cl.getMethod("simple",null);
//输出方法名
System.out.println(mothod2);
//调用该构造方法
mothod2.invoke(s,null);
//调用有返回型的方法
Method method3=cl.getMethod("a3",int.class);
System.out.println(method3);
method3.invoke(s,10);
//private的方法
Method method4=cl.getDeclaredMethod("a4",null);
method4.setAccessible(true);
method4.invoke(s,null);
//反射主方法
Method method5=cl.getMethod("main",String[].class);
System.out.println(method5);
//以下两种参数形式都可以
//method4.invoke(null,(Object)new String[]{"aa","bb"});
method5.invoke(null,new Object[]{new String[]{"aa","bb"}});
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}/* catch (InstantiationException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}*/
}
@org.junit.Test
public void test3()
{
try {
Class cl=Class.forName("Main.simple");
//实例化一个对象
simple sim=new simple();
Field f=cl.getField("s");
//获取域的类型
Class type=f.getType();
System.out.println(type);
//获取狱的名字
//String name=f.getName();
//得到域的值
Object value=f.get(sim);
//判断域的类型,因为在此之前不知道该类型
if(type.equals(String.class))
{
String s=(String)value;
System.out.println(s);
}
//获得private的域
Field l=cl.getDeclaredField("s1");
System.out.println(l.getType());
//用该方法获取private的值,这里就不再用条件语句
l.setAccessible(true);
Object li=l.get(sim);
String lii=(String)li;
System.out.println(lii);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
} catch (SecurityException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
}