JAVA 反射的简单研究

来源：互联网发布：淘宝可以货到付款不编辑：程序博客网时间：2024/06/06 04:35

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

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);
}
}
}

结果：

1 0