Java---类反射(2)---类反射加强

经过前面的一篇博客，Java—类反射(1)，相信大家对类反射有了一定的了解了。

下面来进行对类反射的加强，了解一下怎么通过类反射去new一个对象，

怎么通过类反射去访问其他类的方法。

怎么通过类反射去访问其他类的成员变量。

大家也许认为一个类的私有方法，私有的成员变量是其他类访问不到。但是，类反射是可以通过暴力访问去访问的。

还有：最后要模拟Java内省的功能

类的调用（调用类中的成员）

★ 构造类对象

使用构造器新建对象。根据指定的参数类型找到相应的构造函数，传入相应参数调用执行，以创建一个新的对象实例。

代码示例

Person类代码：

package cn.hncu.reflect;

import java.io.IOException;

/**
 * @author 陈浩翔
 *
 * @version 1.0 2016-5-2
 */
public class Person extends Parent {
    String name;
    private int age;
    public int num;
    public static String schoolName;

    public Person() {
        this("naName", 0);
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(int age) throws IOException, NumberFormatException {
        this("naName", age);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    protected void setAge(int age) {
        this.age = age;
    }

    private int sum(int a) {
        return 0;
    }

    private int sum() {
        return 0;
    }

    int aa(String a, int b) throws IOException, NumberFormatException {

        return 0;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", num=" + num + "]";
    }

}

class Parent{
    public static final int N=100;
}

构造类对象：

package cn.hncu.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * 类反射的演示
 * @author 陈浩翔
 *
 * @version 1.0  2016-5-2
 */
public class ReflectOperateObj {
    private static final String CLASS_FILE_NAME="cn.hncu.reflect.Person";
    public static void main(String[] args) {
        try {
            operateConstructor(CLASS_FILE_NAME);
        } catch (ReflectiveOperationException e) {
            e.printStackTrace();
        }
    }

    /**
     * 一、演示：使用构造器来新建对象
     * @param classFileName
     * @throws ReflectiveOperationException
     */
    private static void operateConstructor(String classFileName) throws ReflectiveOperationException   {
        Class cls = Class.forName(CLASS_FILE_NAME);

        //1 无参构造方法的使用----简单且以后用得最多的
        //Object obj = cls.newInstance();

        //2 有参构造方法的使用
        //用类反射的方式来执行 Object obj = new Person("Jack",20);
        //2.1获取指定"参数列表类型"的构造器---Constructor对象
        Class parameterTypes[] = new Class[2];
        parameterTypes[0] = String.class;
        parameterTypes[1] = int.class;
        Constructor con= cls.getConstructor(parameterTypes);//※1※
        //2.2调用构造器来new对象
        Object initargs[] = new Object[2];
        initargs[0] = new String("Jack");
        initargs[1] = new Integer(20);
        Object resultObj = con.newInstance(initargs);//※2※

        System.out.println(resultObj);
    }
}

输出结果：

Person [name=Jack, age=20, num=0]

★ 调用方法

根据方法名称执行方法。根据方法名与参数类型匹配指定的方法，传入相应参数与对象进行调用执行。若是静态方法，则不需传入具体对象。

代码示例：

Person还是之前的Person类…

演示：调用无参普通方法：

package cn.hncu.reflect;

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

/**
 * 类反射的演示
 * @author 陈浩翔
 *
 * @version 1.0  2016-5-2
 */
public class ReflectOperateObj {
    private static final String CLASS_FILE_NAME="cn.hncu.reflect.Person";
    public static void main(String[] args) {
        try {
            callMethod(CLASS_FILE_NAME);

        } catch (ReflectiveOperationException e) {
            e.printStackTrace();
        }
    }

    /**
     * 二、演示：调用无参普通方法
     * @param classFileName
     * @throws ReflectiveOperationException
     */
    private static void callMethod(String classFileName) throws ReflectiveOperationException{
        Class cls = Class.forName(CLASS_FILE_NAME);
        //需求：调用空参方法 p.toString()

        //1.1必须要用一个类对象
        Object obj = cls.newInstance();
        //1.2用对象来调方法
           //1.2.1先拿到对应方法的Method对象
            Method m = cls.getMethod("toString", null);
            //1.2.2用obj和method来调用该方法
            Object returnValue = m.invoke(obj, null);
            System.out.println(returnValue);
    }
}

输出结果：

Person [name=naName, age=0, num=0]

演示：调用有参普通方法

Person相比之前，加了一个double sum(int , double)方法。

public double sum( int n, double d){
        double sum =0;
        for(int i=1;i<=n;i++){
            sum +=d;
        }
        return sum;
    }

演示类：

package cn.hncu.reflect;

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

/**
 * 类反射的演示
 * @author 陈浩翔
 *
 * @version 1.0  2016-5-2
 */
public class ReflectOperateObj {
    private static final String CLASS_FILE_NAME="cn.hncu.reflect.Person";
    public static void main(String[] args) {
        try {
            callMethod2(CLASS_FILE_NAME);

        } catch (ReflectiveOperationException e) {
            e.printStackTrace();
        }
    }

    /**
     * 三、演示：调用有参普通方法
     * @param classFileName
     * @throws ReflectiveOperationException
     */
    private static void callMethod2(String classFileName) throws ReflectiveOperationException{
        Class cls = Class.forName(CLASS_FILE_NAME);
        //需求：调用有参方法 p.sum(10,2.34)

        //1.1必须要用一个类对象
        Object obj = cls.newInstance();
        //**1.2用对象来调方法
            //***1.2.1先拿到对应方法的Method对象
            Class parameterTypes[] = new Class[2];//形参列表---类型列表---Class数组
            //paramTypes[0]=int.class;//OK
            parameterTypes[0]=Integer.TYPE;//OK
           //paramTypes[0]=Integer.class;//ERROR: 因为Integer.class对应的是Integer类型，不是int类型。而Integer.TYPE是指int类型
            parameterTypes[1]=double.class;
            Method method = cls.getMethod("sum", parameterTypes);

           //***1.2.2用obj和method来调用该方法
            Object[] args = new Object[2];
            args[0] = 10;
            args[1] = 2.34;
            Object returnObj = method.invoke(obj, args);

            System.out.println(returnObj);
    }
}

输出结果：

23.4

演示：调用静态方法

Person类加了一个静态方法show();

public static void show(){
        System.out.println("show.........");
    }

演示类：

package cn.hncu.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
/**
 * 类反射的演示
 * @author 陈浩翔
 *
 * @version 1.0  2016-5-2
 */
public class ReflectOperateObj {
    private static final String CLASS_FILE_NAME="cn.hncu.reflect.Person";
    public static void main(String[] args) {
        try {
            callMethod3(CLASS_FILE_NAME);
        } catch (ReflectiveOperationException e) {
            e.printStackTrace();
        }
    }
    /**
     * 四、演示：调用静态方法---不需要对象就可以调，其它的跟普通方法一样
     * @param classFileName
     * @throws ReflectiveOperationException
     */
    private static void callMethod3(String classFileName) throws ReflectiveOperationException{
        Class cls = Class.forName(CLASS_FILE_NAME);
        //调用static show();
        Method methed = cls.getMethod("show", null);
        methed.invoke(null, null);
    }
}

输出结果：

show.........

★ 获取与设置属性值

根据属性名称读取与修改属性的值，访问非静态属性需传入对象为参数。

代码示例：

Person还是之前的类；

现在看演示类：

package cn.hncu.reflect;

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

/**
 * 类反射的演示
 * @author 陈浩翔
 *
 * @version 1.0  2016-5-2
 */
public class ReflectOperateObj {
    private static final String CLASS_FILE_NAME="cn.hncu.reflect.Person";
    public static void main(String[] args) {
        try {
            changeFieldValue(CLASS_FILE_NAME);
        } catch (ReflectiveOperationException e) {
            e.printStackTrace();
        }
    }

    /**
     * 五、演示根据属性名称读取和修改属性的值
     * @param classFileName
     * @throws ReflectiveOperationException
     */
    private static void changeFieldValue(String classFileName) throws ReflectiveOperationException{
        Class cls = Class.forName(CLASS_FILE_NAME);
        //需求：给一个对象的某属性设置值，如： p.num=123
                //1.1必须要用一个类对象
        Object obj = cls.newInstance();
        //1.2设置该对象的指定属性
           //1.2.1先拿到对应的Field对象
            Field field  =  cls.getField("num");//获取属性“num”对应的Field对象
            //设置属性值

                field.set(obj, 1234);

            //读取属性值
                System.out.println(field.getInt(obj));//1234----返回的是int类型，如果明确数据类型，用这种更好
                System.out.println(field.get(obj));//1234----返回的是Object类型,是通用的

        Person p = new Person();
        p.num=999;
        System.out.println(field.getInt(p));//999,new 谁调谁

    }
}

暴力访问其他类的私有方法，私有成员变量，私有构造方法：

Person类加了一个私有方法：abc();

    private int abc(){
        System.out.println("abc....");
        return 10;
    }

演示暴力访问：

package cn.hncu.reflect;

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

/**
 * 类反射暴力访问其他类的演示
 * @author 陈浩翔
 *
 * @version 1.0  2016-5-2
 */
public class ReflectOperateObj {
    private static final String CLASS_FILE_NAME="cn.hncu.reflect.Person";
    public static void main(String[] args) {
        try {
            brokeAccess(CLASS_FILE_NAME);
        } catch (ReflectiveOperationException e) {
            e.printStackTrace();
        }
    }

    /**
     * 六、演示：暴力访问
     * @param classFileName
     */
    private static void brokeAccess(String classFileName) throws ReflectiveOperationException{
        Class cls = Class.forName(CLASS_FILE_NAME);

        Object obj = cls.newInstance();
        //访问Person中私有的方法abc()
        Method m = cls.getDeclaredMethod("abc",null);
        //只要打开访问权限的开关，就可以暴力访问了
        m.setAccessible(true);
        Object returnObj = m.invoke(obj, null);

        System.out.println("returnObj= "+returnObj);
        //*************
        //有关暴力访问的知识点
        //其实中要在访问之前调用一下AccessibleObject类中的setAccessible()方法且传入boolean型变量就可以
        //而AccessibleObject类是Constructor、Field和Method三个类的父类，因此这三者都能进行暴力访问!
    }
}

输出结果：

abc....
returnObj= 10

看，访问到了吧。就算你的类设为私有的，一样能访问，是不是很神奇啊，

O(∩_∩)O哈哈~。

练习（模拟Java内省的功能）

★ 准备工作

定义一个Model类，里面所有的属性都是private的，然后为每个属性提供getter和setter方法；

再准备一个Map，map的key值都是类里面的属性字段的字符串表示，值任意。

Model类：

UserModel ：

package cn.hncu.reflect.myBeanUtils;

/**
 * @author 陈浩翔
 *
 * @version 1.0  2016-5-2
 */
public class UserModel {
    private String uuid;
    private String name;
    private int age;
    public String getUuid() {
        return uuid;
    }
    public void setUuid(String uuid) {
        this.uuid = uuid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((uuid == null) ? 0 : uuid.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        UserModel other = (UserModel) obj;
        if (uuid == null) {
            if (other.uuid != null)
                return false;
        } else if (!uuid.equals(other.uuid))
            return false;
        return true;
    }

    @Override
    public String toString() {
        return "UserModel [uuid=" + uuid + ", name=" + name + ", age=" + age
                + "]";
    }

}

bookModel:

package cn.hncu.reflect.myBeanUtils;

public class bookModel {
    private String uuid;
    private String name;
    private double inPrice;
    private double outPrice;
    private int num;
    public String getUuid() {
        return uuid;
    }
    public void setUuid(String uuid) {
        this.uuid = uuid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getInPrice() {
        return inPrice;
    }
    public void setInPrice(double inPrice) {
        this.inPrice = inPrice;
    }
    public double getOutPrice() {
        return outPrice;
    }
    public void setOutPrice(double outPrice) {
        this.outPrice = outPrice;
    }
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((uuid == null) ? 0 : uuid.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        bookModel other = (bookModel) obj;
        if (uuid == null) {
            if (other.uuid != null)
                return false;
        } else if (!uuid.equals(other.uuid))
            return false;
        return true;
    }
    @Override
    public String toString() {
        return "bookModel [uuid=" + uuid + ", name=" + name + ", inPrice="
                + inPrice + ", outPrice=" + outPrice + ", num=" + num + "]";
    }

}

★ 真正的工作

设计一个方法Object getModel(Map map,Class cls)，传入一个包含所有值的Map，然后再传入Model类的class，那么返回Model类的实例，这个实例里面已经包含好了所有相关的数据。也就是把Map中的数据通过反射，设置回到Model类实例中。

没有用泛型的（一）：

MyBeanUtils

package cn.hncu.reflect.myBeanUtils;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Map;

/**
 *
 * @author 陈浩翔
 *
 * @version 1.0  2016-5-2
 */
public class MyBeanUtils {
    public static Object populate(Class cls,Map map) throws ReflectiveOperationException{
        Object obj =null;
        //1 用类反射new出对象
        obj = (Object) cls.newInstance();
        //2 再用类反射对新new的对象设置属性值(必须遵守Java设置规范)--即通过setter方法设置
            //2.1遍历出所有该类声明的属性
        Field fields[] = cls.getDeclaredFields();
        for(Field fld : fields){

            //获取该fld对象所代表的属性名
            String fldName = fld.getName();

            //根据属性名，到map中去读取数据，只有数据非空才需要给该属性设置值
            Object mapValue = map.get(fldName);
            if(mapValue==null){

                //如果map中不存在对应的属性数据，我们在这里给出提示信息
                System.out.println(fldName+"的数据为空！");
            }else{
                //如果map中存在对应的属性数据，则由属性名得出它的setter方法的名字
                String setName = "set"+fldName.substring(0, 1).toUpperCase()+fldName.substring(1);

                //根据方法名和参数的数据类型(其实就是属性的类型)，获得Method对象
                Class parameterTypes[] =new Class[1];
                parameterTypes[0] = fld.getType();
                Method method = cls.getDeclaredMethod(setName, parameterTypes);//最好不要用getMethod，因为这样可能会用到父类的方法
                //这里不用担心会访问到私有的，因为权限没放开。

                //调用该method对象所代表的方法
                Object args[] = new Object[1];
                args[0] = mapValue;
                method.invoke(obj, args);
            }
        }
        return obj;
    }
}

测试类：

package cn.hncu.reflect.myBeanUtils;

import java.util.HashMap;
import java.util.Map;

/**
 * @author 陈浩翔
 *
 * @version 1.0  2016-5-2
 */
public class Client {
    public static void main(String[] args) {
        test1();
    }
    private static void test1() {
        Map map = new HashMap();

        map.put("uuid", "X001");
        map.put("name", "阿敏");
        map.put("age", 123);

        try {
            Object userModel = MyBeanUtils.populate(UserModel.class, map);
            System.out.println(userModel);
        } catch (ReflectiveOperationException e) {
            e.printStackTrace();
        }
    }
}

//这个测试全部都设置了值。

输出结果：

UserModel [uuid=X001, name=阿敏, age=123]

还有可能测试的数据不全。

我们在这里是写了一个输出的（为了看清楚），实际中，是不需要输出的。

package cn.hncu.reflect.myBeanUtils;

import java.util.HashMap;
import java.util.Map;

/**
 * @author 陈浩翔
 *
 * @version 1.0  2016-5-2
 */
public class Client {
    public static void main(String[] args) {
        test2();
    }
    private static void test2() {
        Map map = new HashMap();
        map.put("uuid", "X001");
        map.put("name", "阿敏");

        try {
            Object userModel = MyBeanUtils.populate(UserModel.class, map);
            System.out.println(userModel);
        } catch (ReflectiveOperationException e) {
            e.printStackTrace();
        }
    }
}

输出结果：

age的数据为空！
UserModel [uuid=X001, name=阿敏, age=0]

为了让那个类通用，我们还测试了bookModel类：

package cn.hncu.reflect.myBeanUtils;

import java.util.HashMap;
import java.util.Map;

/**
 * @author 陈浩翔
 *
 * @version 1.0  2016-5-2
 */
public class Client {
    public static void main(String[] args) {
        test3();
    }

    private static void test3() {
        Map map = new HashMap();
        map.put("uuid", "001");
        map.put("name", "红楼梦");
        map.put("inPrice", 20.5);
        map.put("num", 123);

        try {
            Object bookModel = MyBeanUtils.populate(bookModel.class, map);
            System.out.println(bookModel);
        } catch (ReflectiveOperationException e) {
            e.printStackTrace();
        }
    }
}

同样，有一个数据是不全的，

输出结果：

outPrice的数据为空！
bookModel [uuid=001, name=红楼梦, inPrice=20.5, outPrice=0.0, num=123]

如果把数据改全：

private static void test3() {
        Map map = new HashMap();
        map.put("uuid", "001");
        map.put("name", "红楼梦");
        map.put("inPrice", 20.5);
        //之前没有的数据---outPrice，现在补上
        map.put("outPrice", 50.5);
        map.put("num", 123);

        try {
            Object bookModel = MyBeanUtils.populate(bookModel.class, map);
            System.out.println(bookModel);
        } catch (ReflectiveOperationException e) {
            e.printStackTrace();
        }
    }

输出结果：

bookModel [uuid=001, name=红楼梦, inPrice=20.5, outPrice=50.5, num=123]

好了，测试完全通过。

只是那个工具类有强转，好像不太好，怎么办呢。

这个时候，就可以用泛型了。

下面是用泛型的版本，至于测试，我就只测试一次了。

package cn.hncu.reflect.myBeanUtils;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Map;

public class MyBeanUtils2 {
    public static <T>T populate(Class<T> cls,Map<String, Object> map) throws ReflectiveOperationException{
        T t = null;
         //1 用类反射new出对象
        t = cls.newInstance();
         //2 再用类反射对新new的对象设置属性值(必须遵守Java设置规范)--即通过setter方法设置
           //2.1遍历出所有该类声明的属性
        Field flds[] = cls.getDeclaredFields();
        for(Field fld:flds){
            //获取该fld对象所代表的属性名
            String fldName = fld.getName();

            Object mapV = map.get(fldName);
             //根据属性名，到map中去读取数据，只有数据非空才需要给该属性设置值
            if(mapV==null){
                //如果map中不存在对应的属性数据，我们在这里给出提示信息
                System.out.println(fldName+"数据为空！");
            }else{

                 //如果map中存在对应的属性数据，则由属性名得出它的setter方法的名字
                String setName = "set"+fldName.substring(0,1).toUpperCase()+fldName.substring(1);

                 //根据方法名和参数的数据类型(其实就是属性的类型)，获得Method对象
                Class parameterTypes[] = new Class[1];
                parameterTypes[0] = fld.getType();
                Method m = cls.getDeclaredMethod(setName, parameterTypes);

                 //调用该method对象所代表的方法
                Object args[] = new Object[1];
                args[0]=mapV;
                m.invoke(t, args);
            }
        }
        return t;
    }
}

测试类：

package cn.hncu.reflect.myBeanUtils;

import java.util.HashMap;
import java.util.Map;

/**
 * @author 陈浩翔
 *
 * @version 1.0  2016-5-2
 */
public class Client {
    public static void main(String[] args) {
        test4();
    }

    private static void test4() {
        Map map = new HashMap();
        map.put("uuid", "001");
        map.put("name", "红楼梦");
        map.put("inPrice", 20.5);
        //map.put("outPrice", 50.5);
        map.put("num", 123);

        try {
            Object bookModel = MyBeanUtils2.populate(bookModel.class, map);
            System.out.println(bookModel);
        } catch (ReflectiveOperationException e) {
            e.printStackTrace();
        }
    }
}

输出结果为：

outPrice数据为空！
bookModel [uuid=001, name=红楼梦, inPrice=20.5, outPrice=0.0, num=123]

好了，类反射也就这些内容了。结束啦。

其实类反射也挺容易的，就是通过完整的类名，再调用newInstance方法new一个对象。再通过这个对象来进行操作方法Method，构造方法（调用构造器来new对象

Object initargs[] = new Object[2];

initargs[0] = new String(“Jack”);

initargs[1] = new Integer(20);

Object resultObj = con.newInstance(initargs);），

成员变量Field。

要访问私有的，只要打开访问权限的开关，就可以暴力访问了

也就是.setAccessible(true);方法，设置为true。

时间： 2024-12-19 01:57:58

Java---类反射(2)---类反射加强的相关文章

使用反射创建Bean、Spring中是如何根据类名配置创建Bean实例、Java提供了Class类获取类别的字段和方法，包括构造方法

Java提供了Class类,可以通过编程方式获取类别的字段和方法,包括构造方法 获取Class类实例的方法: 类名.class 实例名.getClass() Class.forName(className) public class RefTest { @Test public void testRef(){ //Class cls = RefTest.class; //Class.forName("com.jboa.service.RefTest"); //new RefTest()

java 反射提取类信息， 动态代理 和过滤某些方法演示

package org.rui.classts.reflects; import java.lang.reflect.Constructor; import java.lang.reflect.Method; import java.util.regex.Pattern; /** * 提取 类的 方法 构造器 * @author lenovo * */ //{args:ShowMethods} //查看一个类的所有方法和构造器 public class ShowMethods { private

java android布局里的控件值 反射绑定给实体类，实体类绑定给控件，表单提交绑定很有用

注意了:根据实际情况,添加实体里字段的类型,控件类型的判断才可使用.这里控件只有TextView EditText 实体类字段只有String int类型,带值的控件添加tag ,值和实体类的字段值一致 package ice.ui.service; import java.lang.reflect.Field;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;import jav

黑马程序员——Java基础---反射Class类、Constructor类、Field类

------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------- 反射的应用场景 一.概述 反射技术: Java反射机制是在运行状态中,对于任意一个类,都能够知道这个类中的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法的功能称为java语言的

Java反射（二）利用反射分析类的能力

利用反射分析类能力的类的源码如下(来源于<Java核心技术>卷一): package testreflection; import java.util.*; import java.lang.reflect.*; /** * 这个类利用反射打印出一个类的所有特征 * * @version 1.1 2004-02-21 * @author Cay Horstmann */ public class ReflectionTest { public static void main(String[]

java动态加载指定的类或者jar包反射调用其方法

序言 有时候,项目中会用到java动态加载指定的类或者jar包反射调用其方法来达到模块的分离,使各个功能之间耦合性大大降低,更加的模块化,代码利用率更高.模式中的代理模式就用到java的这一机制.下边就让我们通过代码来看看如何实现此功能. 代码详细 package loadjarclass; import java.io.File; import java.lang.reflect.Method; import java.net.URL; import java.net.URLClassLoad

java事件响应方法汇总（容器类监听、监听器类、AbstractAction、反射）

Java图形用户界面中,处理事件时所必须的步骤是: 1.创建接受响应的组件(控件)2.实现相关事件监听接口3.注册事件源的动作监听器4.事件触发时的事件处理 相应的可以通过以下的集中方式来作出事件响应. [java] view plaincopyprint? <span style="font-size: 18px;">一.容器类监听 效果:单击窗体中的三个按钮,实现相应的相应时间. </span><pre class="java" n

通过Java反射测试类私有成员

在Java开发阶段,因为追求架构规范和遵循设计原则,所以要用private和protected修饰符去定义类的成员方法.变量.常量,这使得代码具封装性.内聚性等,但在测试阶段会造成一定的不便.通过Java的反射机制,便能很好地解决该问题. ReflectUtil.java //...... /** * @author yumin * @since 2015-03-02 14:52 */ public class ReflectUtil { private ReflectUtil() { } //

java动态载入指定的类或者jar包反射调用其方法

序言 有时候.项目中会用到java动态载入指定的类或者jar包反射调用其方法来达到模块的分离,使各个功能之间耦合性大大减少,更加的模块化.代码利用率更高.模式中的代理模式就用到java的这一机制. 下边就让我们通过代码来看看怎样实现此功能. 代码具体 package loadjarclass; import java.io.File; import java.lang.reflect.Method; import java.net.URL; import java.net.URLClassLoa

Java 反射工具类

package com.su.dolphin.utils; import java.lang.reflect.Array; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; /** * * @className: ReflectionUti