JAVA 反射的简单研究

代码：（获取运行时类中的方法、返回值、参数）

package ceshi;

import java.lang.reflect.Method;

/**
 * [说明/描述]
 * @author HanJia
 * @date 2016-8-30 下午4:18:36
 * @company
 * @version 1.0
 * @copyright copyright (c) 2016
 */
public class Pee {

    private int f1( Object p, int x ) throws NullPointerException {
        if ( p == null )
            throw new NullPointerException();
        return x;
    }
    
    public static void main(String[] args) {
        try{
            //运行时获取类
            Class cls = Class.forName("ceshi.Pee");
            //获取类中的所有方法
            Method methlist[] = cls.getDeclaredMethods();
            for (int i = 0; i < methlist.length; i++) {
                Method m = methlist[i];
                //当前方法的名字
                System.out.println("name = "+m.getName());
                //当前方法的类
                System.out.println("decl class = "+m.getDeclaringClass());
                //获取当前方法中的所有参数
                Class pvec[] = m.getParameterTypes();
                for (int j = 0; j < pvec.length; j++) {
                    //获取当前参数
                    System.out.println("param #"+j+" "+pvec[j]);
                }
                //获取当前方法可能抛出的异常
                Class evec[] = m.getExceptionTypes();
                for (int j = 0; j < evec.length; j++) {
                    //打印当前方法的异常
                    System.out.println("exc #"+j+" "+evec[j]);
                }
                //打印当前方法的返回值类型
                System.out.println("return type = "+m.getReturnType());
                //分割线
                System.out.println("-----------");
            }
        }catch(Throwable e){
            System.out.println(e);
        }
    }
}

结果：

代码：（获取构造函数 名字 参数 异常）

package ceshi;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

/**
 * [说明/描述]
 * @author HanJia
 * @date 2016-8-30 下午4:18:36
 * @company
 * @version 1.0
 * @copyright copyright (c) 2016
 */
public class Pee {
    //构造方法
    public Pee(){
    }
    protected Pee(int i,double d){
    }
    private Pee(int i){
    }
    
    public static void main(String[] args) {
        try{
            //获取运行时的类
            Class cls = Class.forName("ceshi.Pee");
            //获取当前类的构造方法
            Constructor ctr[] = cls.getDeclaredConstructors();
            for (int i = 0; i < ctr.length; i++) {
                //当前构造方法
                Constructor ct = ctr[i];
                //打印构造方法的名字
                System.out.println("name = "+ct.getName());
                //打印构造方法的类
                System.out.println("decl class ="+ct.getDeclaringClass());
                //获取当前构造方法的参数
                Class pt[] = ct.getParameterTypes();
                for (int j = 0; j < pt.length; j++) {
                    //打印构造方法
                    System.out.println("param #"+j+" "+pt[j]);
                }
                //当前构造方法中可能的异常
                Class e[] = ct.getExceptionTypes();
                for (int j = 0; j < e.length; j++) {
                    //打印构当前造方法中的异常
                    System.out.println("exc #"+j+" "+e[j]);
                }
                //打印分割线
                System.out.println("-------");
            }
        }catch(Throwable e){
            System.out.println(e);
        }
    }
}

结果：

代码：（获取当前类的变量 名字 类型 修饰符）

package ceshi;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/**
 * [获取类的字段（域）]
 * @author HanJia
 * @date 2016-8-30 下午4:18:36
 * @company
 * @version 1.0
 * @copyright copyright (c) 2016
 */
public class Pee {
    //私有变量
    private double d;
    //常亮
    public static final int i=37;
    //字符串
    String s="testing";
    public static void main(String args[]){
        try{
            //获取运行时的类
            Class cls=Class.forName("ceshi.Pee");
            //获取当前类的属性
            Field fd[] = cls.getDeclaredFields();
            for (int i = 0; i < fd.length; i++) {
                Field fld = fd[i];
                //打印当前属性的名字
                System.out.println("name ="+fld.getName());
                //打印当前的类
                System.out.println("decl class ="+fld.getDeclaringClass());
                //打印当前属性的类型
                System.out.println("type ="+fld.getType());
                //打印当前属性的修饰符
                int md=fld.getModifiers();
                //打印当前属性的修饰符
                System.out.println("modifiers ="+Modifier.toString(md));
                //打印分割线
                System.out.println("-----------");
            }
        }catch(Throwable e){
            System.err.println(e);
        }
    }
}

结果：

代码：（根据方法名字来执行方法）

package ceshi;
/**
 * 根据方法名字来执行方法
 */
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;




public class Pee {
public int add(int a,int b){
return a+b;
}
public static void main(String[] args) {
try{
//获取Pee运行时的类
/*Class cls=Class.forName("ceshi.Pee");
//建立类数组，存放方法参数的类
Class Partypes[]=new Class[2];
//获取int的class类
//Integer.TYPE==int.class//是int基本类型的class引用
//Integer.class//是int的封装类Integer的引用
Partypes[0]=Integer.TYPE;
Partypes[1]=Integer.TYPE;
//获取类中特定的方法add
Method meth=cls.getMethod("add",Partypes);*/

Method meth=Class.forName("ceshi.Pee").getMethod("add",new Class[]{Integer.TYPE,Integer.TYPE});

//创建一个类的对象
/*Pee methobj=new Pee();
//创建一组参数
Object arglist[]=new Object[2];
arglist[0]=new Integer(37);
arglist[1]=new Integer(47);
//调用方法
Object retobj= meth.invoke(methobj, arglist);
//获取方法的返回值转换类型
Integer retval=(Integer)retobj;*/

String retval=meth.invoke(new Pee(),new Object[]{new Integer(37),new Integer(47)}).toString();
System.out.println(retval);

//打印方法的返回值
//System.out.println(retval.intValue());


}catch(Throwable e){
System.err.println(e);
}
}
}

结果：84

代码：（创建新的对象）

package ceshi;
/**
 * 创建新的对象
 */
import java.lang.reflect.Constructor;




public class Pee {
//无参构造器
public Pee(){
}
//有参构造器
public Pee(int a,int b){
System.out.println("a ="+ a + "b ="+ b);
}

public static void main(String[] args) {
try{
//获取运行中的类
Class cls=Class.forName("ceshi.Pee");
//创建类数组
Class partypes[] = new Class[2];
//设置方法参数类型
partypes[0] = Integer.TYPE;
partypes[1] = Integer.TYPE;
//调用构造函数传入参数
Constructor ct = cls.getConstructor(partypes);
//创建参数
Object arglist[] = new Object[2];
arglist[0] = new Integer(37);
arglist[1] = new Integer(47);
//获取对象
Object retobj = ct.newInstance(arglist);
}catch(Throwable e){
System.err.println(e);
}
}
}

结果：

代码：（改变字段（域）的值）

package ceshi;
/**
 * 改变字段（域）的值
 */
import java.lang.reflect.Field;




public class Pee {

public double d;

public static void main(String[] args) {
try{
//获取运行时的类
Class cls=Class.forName("ceshi.Pee");
//获取该类的属性d
Field fld = cls.getField("d");
//创建类对象
Pee fld2 = new Pee();
//默认值为0.0
System.out.println("d = " + fld2.d);
//为属性赋值
fld.setDouble(fld2, 12.23);
//打印结果
System.out.println("d = " + fld2.d);
}catch(Throwable e){
System.err.println(e);
}
}
}

结果：