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 反射的简单研究

java 反射的简单研究

Java反射研究

java.lang.reflect包 Constructor、Field、Method的父类是AccessibleObject; 一、获得Class对象 Class c = Cl...

我是如何成为一名python大咖的?

人生苦短,都说必须python,那么我分享下我是如何从小白成为Python资深开发者的吧。2014年我大学刚毕业..

Java反射研究(3)

十一、工厂设计模式 1.最简单的工厂设计模式 场景:有一个Fruit接口,Apple类和Orange类都实现了Fruit接口,Factory用来生产水果; import ja...

Java反射机制研究

Java反射机制研究

Java反射探索研究

本文详细深入讲解是Java中反射的机制,并介绍了如何通过反射来生成对象、调用函数、取得字段、设置字段的方法。最后,给出了一些反射常用到的实例。

Java反射研究(3)

十一、工厂设计模式 1.最简单的工厂设计模式 场景:有一个Fruit接口,Apple类和Orange类都实现了Fruit接口,Factory用来生产水果; view pl...

Java反射研究(2)

接Java反射研究(1) 九、调用特定方法 Method m = c1.getMethod("funcname",Class...c);   //funcname表示调用方法的名称...

.net反射的研究

使用反射的一些记录 通过反射调用类型中的方法 由于.NET中包含了类型的元数据,所以我们可以在运行时获得一个类型的详细信息,并对其做相应的操作。使用到的类 为了使程序稍微复杂一点,我们假定一种场...

简单的Java的反射

Java的反射什么是Java的反射?在运行期间得到类的各种信息,包括变量、构造器、方法等并对其惊醒操作。这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制 废话不多说,直接上 首...

java反射机制深入研究

Java反射机制深入研究 Java 反射是Java语言的一个很重要的特征,它使得Java具体了“动态性”。 在Java运行时环境中,对于任意一个类,能否知道这个类有哪些属性和方法?对于任意一个...
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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