JAVA 反射的简单研究

转载 2016年08月30日 17:02:56

代码:(获取运行时类中的方法、返回值、参数)

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


结果:

相关文章推荐

java中反射的简单了解(一)

源码: Student.java package com.ifly.classpractice.day7_29.reflect; public class Student { private...

java泛型和反射的简单例子

public static void main(String[] args) { // 实例化这个类,泛型的类型定义为string,参数给字符串,得到的该类型为string。 fx fx1...

java反射的作用------hibernate插入功能的j简单实现

很久以前在看java反射的相关内容,但是运行来运行去,

Java反射的简单例子

反射技术: 通过配置文件动态获取类,仅在配置文件中添加类名,而不用修改源码 当程序写好后直接在配置文件里添加新增类名就可以了 public class ReflectTest { public...

java中反射的简单了解(二)

Class类 如果要完成反射,那么必须了解Class类 实例1:通过对象取得包名和类名 package org.siu; class Test { } public clas...

java反射的简单使用

前几天项目中遇到一个吧叫有意思的事情,那就是一个InsertHbase的工具类接收一个对象,然后获取到对象的每一个属性及其值,最后Insert到Hbase中 如:public class Peopl...

Java反射的简单应用

反射机制在前后端交互中的简单应用

反射的简单运用

  • 2012年10月07日 23:16
  • 47KB
  • 下载

简单抽象工厂和反射的入门例子

  • 2012年07月19日 16:49
  • 78KB
  • 下载

反射的作用之spring的简单模拟

我们都知道spring框架主要起管理作用,它的核心配置文件时bean.xml,那么他是如何通过配置文件来管理这么多实体类的呢。下面看简单的模拟。代码是跟着马老师敲的。 先建立如图所示框架...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:JAVA 反射的简单研究
举报原因:
原因补充:

(最多只允许输入30个字)