学步园

package crazypebble.reflectiontest;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.Serializable;

public class ReflectionTest extends Object implements ActionListener,Serializable{
    // 成员变量
    private int bInt;
    public Integer bInteger = new Integer(4);
    public String strB = "crazypebble";
    private String strA;
    
    // 构造函数
    public ReflectionTest() {
        
    }
    
    protected ReflectionTest(int id, String name) { 
        
    }
    
    // 成员方法
    public int abc(int id, String name) {
        System.out.println("crazypebble ---> " + id + "-" + name);
        return 0;
    }
    
    protected static void edf() {
        
    }
    
    @Override
    public void actionPerformed(ActionEvent e) {
        // TODO Auto-generated method stub
        
    }
    
}

    /**
     * 获取反射类中的构造方法
     * 输出打印格式："Modifier修饰域   构造方法名(参数类型列表)"
     */
    public static void get_Reflection_Constructors(ReflectionTest r) {
        
        Class temp = r.getClass();
        String className = temp.getName();        // 获取指定类的类名
        
        try {
            Constructor[] theConstructors = temp.getDeclaredConstructors();           // 获取指定类的公有构造方法
            
            for (int i = 0; i < theConstructors.length; i++) {
                int mod = theConstructors[i].getModifiers();    // 输出修饰域和方法名称
                System.out.print(Modifier.toString(mod) + " " + className + "(");

                Class[] parameterTypes = theConstructors[i].getParameterTypes();       // 获取指定构造方法的参数的集合
                for (int j = 0; j < parameterTypes.length; j++) {    // 输出打印参数列表
                    System.out.print(parameterTypes[j].getName());
                    if (parameterTypes.length > j+1) {
                        System.out.print(", ");
                    }
                }
                System.out.println(")");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取反射类的方法
     * 打印输出格式："RetType FuncName(paramTypeList)"
     */
    public static void get_Reflection_Method(ReflectionTest r) {
        
        Class temp = r.getClass();
        String className = temp.getName();
        
        /*
         * Note: 方法getDeclaredMethods()只能获取到由当前类定义的所有方法，不能获取从父类继承的方法
         * 方法getMethods() 不仅能获取到当前类定义的public方法，也能得到从父类继承和已经实现接口的public方法
         * 请查阅开发文档对这两个方法的详细描述。
         */
        //Method[] methods = temp.getDeclaredMethods();
        Method[] methods = temp.getMethods();
        
        for (int i = 0; i < methods.length; i++) {
            
            // 打印输出方法的修饰域
            int mod = methods[i].getModifiers();
            System.out.print(Modifier.toString(mod) + " ");
            
            // 输出方法的返回类型
            System.out.print(methods[i].getReturnType().getName());    
            
            // 获取输出的方法名
            System.out.print(" " + methods[i].getName() + "(");
            
            // 打印输出方法的参数列表
            Class[] parameterTypes = methods[i].getParameterTypes();
            for (int j = 0; j < parameterTypes.length; j++) {
                System.out.print(parameterTypes[j].getName());
                if (parameterTypes.length > j+1) {
                    System.out.print(", ");
                }
            }
            System.out.println(")");
        }
    }

    /**
     * 获取反射类中的属性和属性值
     * 输出打印格式："Modifier Type : Name = Value"
     * Note: 对于未初始化的指针类型的属性，将不输出结果
     */
    public static void get_Reflection_Field_Value(ReflectionTest r) {
        
        Class temp = r.getClass();    // 获取Class类的对象的方法之一
        
        try {
            System.out.println("public 属性");
            Field[] fb = temp.getFields();
            for (int i = 0; i < fb.length; i++) {
                
                Class cl = fb[i].getType();    // 属性的类型
                
                int md = fb[i].getModifiers();    // 属性的修饰域
                
                Field f = temp.getField(fb[i].getName());    // 属性的值
                f.setAccessible(true);
                Object value = (Object)f.get(r);
                
                // 判断属性是否被初始化
                if (value == null) {
                    System.out.println(Modifier.toString(md) + " " + cl + " : "      + fb[i].getName());
                }
                else {
                    System.out.println(Modifier.toString(md) + " " + cl + " : "      + fb[i].getName() + " = " + value.toString());
                }
            }
            
            System.out.println("public & 非public 属性");
            Field[] fa = temp.getDeclaredFields();
            for (int i = 0; i < fa.length; i++) {
                
                Class cl = fa[i].getType();    // 属性的类型
                
                int md = fa[i].getModifiers();    // 属性的修饰域
                
                Field f = temp.getDeclaredField(fa[i].getName());    // 属性的值
                f.setAccessible(true);    // Very Important
                Object value = (Object) f.get(r);
                
                if (value == null) {
                    System.out.println(Modifier.toString(md) + " " + cl + " : "      + fa[i].getName());
                }
                else {
                    System.out.println(Modifier.toString(md) + " " + cl + " : "  + fa[i].getName() + " = " + value.toString());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

package crazypebble.reflectiontest;

import java.lang.reflect.Constructor;

import java.lang.reflect.Method;
public class LoadMethod {
    /**

     * 在运行时加载指定的类，并调用指定的方法

     * @param cName            Java的类名

     * @param MethodName    方法名

     * @param types            方法的参数类型

     * @param params        方法的参数值

     * @return

     */

    public Object Load(String cName, String MethodName, String[] types, String[] params) {
        Object retObject = null;
        try {

            // 加载指定的类

            Class cls = Class.forName(cName);    // 获取Class类的对象的方法之二
            // 利用newInstance()方法，获取构造方法的实例

            // Class的newInstance方法只提供默认无参构造实例

            // Constructor的newInstance方法提供带参的构造实例

            Constructor ct = cls.getConstructor(null);

            Object obj = ct.newInstance(null);

            //Object obj = cls.newInstance();
            // 构建 方法的参数类型

            Class paramTypes[] = this.getMethodTypesClass(types);
            // 在指定类中获取指定的方法

            Method meth = cls.getMethod(MethodName, paramTypes);
            // 构建 方法的参数值

            Object argList[] = this.getMethodParamObject(types, params);
            // 调用指定的方法并获取返回值为Object类型

            retObject = meth.invoke(obj, argList);
        } catch (Exception e) {

            System.err.println(e);

        }
        return retObject;

    }
    /**

     * 获取参数类型，返回值保存在Class[]中

     */

    public Class[] getMethodTypesClass(String[] types) {

        Class[] cs = new Class[types.length];
        for (int i = 0; i < cs.length; i++) {

            if (types[i] != null || !types[i].trim().equals("")) {

                if (types[i].equals("int") || types[i].equals("Integer")) {

                    cs[i] = Integer.TYPE;

                }

                else if (types[i].equals("float") || types[i].equals("Float")) {

                    cs[i] = Float.TYPE;

                }

                else if (types[i].equals("double") || types[i].equals("Double")) {

                    cs[i] = Double.TYPE;