import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
class A extends Object implements ActionListener{
      private int a = 3;
      public Integer b = new Integer(4);
public A(){}
public A(int id,String name){}
public int abc(int id,String name){return 0;}
public void actionPerformed(ActionEvent e){}
}

import java.lang.reflect.*;
class B{
      public static void main(String args[]){
            A r = new A();
            Class temp = r.getClass();
            try{
                   System.out.println("反射类中所有公有的属性");
                   Field[] fb =temp.getFields();
                  for(int j=0;j<fb.length;j++){
                        Class cl = fb[j].getType();
                        System.out.println("fb:"+cl);
                  }

                   System.out.println("反射类中所有的属性");
                  Field[] fa = temp.getDeclaredFields();
                   for(int j=0;j<fa.length;j++){
                        Class cl = fa[j].getType();
                        System.out.println("fa:"+cl);
                  }
                   System.out.println("反射类中私有属性的值");
                  Field f = temp.getDeclaredField("a");
                  f.setAccessible(true);
                  Integer i = (Integer)f.get(r);
                  System.out.println(i);
            }catch(Exception e){
            e.printStackTrace();
      }
}

}

import java.lang.reflect.*;
public class SampleConstructor {
      public static void main(String[] args) {
            A r = new A();
            printConstructors(r);
      }

      public static void printConstructors(A r) {
            Class c = r.getClass();
            //获取指定类的类名
            String className = c.getName();
            try {
                  //获取指定类的构造方法
                  Constructor[] theConstructors = c.getConstructors();
                  for(int i=0; i<theConstructors.length; i++) {
                        //获取指定构造方法的参数的集合
                        Class[] parameterTypes = theConstructors[i].getParameterTypes();

                        System.out.print(className + "(");

                        for(int j=0; j<parameterTypes.length; j++)
                        System.out.print(parameterTypes[j].getName() + " ");

                        System.out.println(")");

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

import java.io.*;
import java.lang.reflect.*;

public class SampleInterface {
      public static void main(String[] args) throws Exception {
            A raf = new A();
            printInterfaceNames(raf);
      }

      public static void printInterfaceNames(Object o) {
            Class c = o.getClass();
            //获取反射类的接口
            Class[] theInterfaces = c.getInterfaces();
            for(int i=0; i<theInterfaces.length; i++)
            System.out.println(theInterfaces[i].getName());
            //获取反射类的父类（超类）
            Class theSuperclass = c.getSuperclass();
            System.out.println(theSuperclass.getName());
      }
}

import java.lang.reflect.*;
public class SampleMethod {

      public static void main(String[] args) {
            A p = new A();
            printMethods(p);
      }

      public static void printMethods(Object o) {
            Class c = o.getClass();
            String className = c.getName();
            Method[] m = c.getMethods();
            for(int i=0; i<m.length; i++) {
                  //输出方法的返回类型
                  System.out.print(m[i].getReturnType().getName());
                  //输出方法名
                  System.out.print(" "+m[i].getName()+"(");
                  //获取方法的参数
                  Class[] parameterTypes = m[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(")");
            }

      }

}

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

public class LoadMethod {
      public Object Load(String cName,String MethodName,String[] type,String[] param){
            Object retobj = null;
            try {
                   //加载指定的Java类
                   Class cls = Class.forName(cName);

                   //获取指定对象的实例
                   Constructor ct = cls.getConstructor(null);
                   Object obj = ct.newInstance(null);

                   //构建方法参数的数据类型
                   Class partypes[] = this.getMethodClass(type);

                   //在指定类中获取指定的方法
                   Method meth = cls.getMethod(MethodName, partypes);

                   //构建方法的参数值
                   Object arglist[] = this.getMethodObject(type,param);

                   //调用指定的方法并获取返回值为Object类型
                   retobj= meth.invoke(obj, arglist);

             }
             catch (Throwable e) {
                   System.err.println(e);
             }
            return retobj;
      }

      //获取参数类型Class[]的方法
      public Class[] getMethodClass(String[] type){
            Class[] cs = new Class[type.length];
            for (int i = 0; i < cs.length; i++) {
                  if(!type[i].trim().equals("")||type[i]!=null){
                        if(type[i].equals("int")||type[i].equals("Integer")){
                              cs[i]=Integer.TYPE;
                        }else if(type[i].equals("float")||type[i].equals("Float")){
                              cs[i]=Float.TYPE;
                        }else if(type[i].equals("double")||type[i].equals("Double")){
                              cs[i]=Double.TYPE;
                        }else if(type[i].equals("boolean")||type[i].equals("Boolean")){
                              cs[i]=Boolean.TYPE;
                        }else{
                        cs[i]=String.class;
                  }
            }
      }
      return cs;
}

//获取参数Object[]的方法
public Object[] getMethodObject(String[] type,String[] param){
      Object[] obj = new Object[param.length];
      for (int i = 0; i < obj.length; i++) {
            if(!param[i].trim().equals("")||param[i]!=null){
                  if(type[i].equals("int")||type[i].equals("Integer")){
                        obj[i]= new Integer(param[i]);
                  }else if(type[i].equals("float")||type[i].equals("Float")){
                        obj[i]= new Float(param[i]);
                  }else if(type[i].equals("double")||type[i].equals("Double")){
                        obj[i]= new Double(param[i]);
                  }else if(type[i].equals("boolean")||type[i].equals("Boolean")){
                        obj[i]=new Boolean(param[i]);
                  }else{
                  obj[i] = param[i];
            }
      }
}
return obj;
}
}