Java反射学习（java reflect）(一)

具有能够分析类能力的程序被称为反射,使用反射库可以编写能够动态操纵Java代码的程序。

一、开始

背景：Java运行时系统始终对所有对象维护一个被称为Runtime的类型标识，然后这货save着每个对象所属类的足迹,虚拟机利用运行时信息选择相应方法执行。保存这些信息的类为Class，取得Class的实例化对象就可以进行下一步的操作了：

• Class类：
• 取得Class类对象的三种方法：
• getClass():
• Hehe e; Class cl=e.getClass();
• forName(String name):
• String   className="java.util.Date"; Class cl=Class.forName(className);
• T.class:
• Class cl1=Date.class;

二、使用反射分析类

发射机制的最重要内容--检测类的结构。

Java.lang.reflect为反射包，里面有以下四个类：

1. Fiend

   属性

   getDeclareFields()  & getFields()

2. Method

   方法

   getDeclareMethods() & getMethods()

3. Constructor

   构造

   getDeclareConstructor()  & getConstructor()

4. Modifier

   修饰

   getModifiers()

对于Fiend , Method , Constructor 都有一个方法 getName() ,可以用来取得属性|方法|构造名，

然后上面每个类最后的两个方法，有Declare的那个是取得全部域、方法、构造器，

　　　　　　　　　　　　　　　没有Declare的那个是取得public型的域、方法、构造器。

对于Modifier，有方法getModifiers()，用来取得一个int型值，放入Modifier.toString(int a)中就能得到对应的修饰法。(即public,private等)。

p.s.对于Modifier的getModifiers()取得int后，还有许多判断方法，都是is开头的.

Code:

　　

         import java.lang.reflect.Constructor;
         import java.lang.reflect.Field;
         import java.lang.reflect.Method;
         import java.lang.reflect.Modifier;
         import java.util.Scanner;
         /**
          * waring : params part will be changed if param was array
          *             ex. byte[] --> [B
          */

         public class ReflectionTest {
             public static void main(String[] args) {
                 String name;
                 if(args.length>0){
                     name=args[0];
                 }else{
                     Scanner in =new Scanner(System.in);
                     System.out.println("Enter class name (e.g. java.util.Date):");
                     name=in.next();
                     System.out.println("Input:"+name);
                 }
                 try {
                     Class cl=Class.forName(name);
                     Class superCl=cl.getSuperclass();    //super one
                     Class[] interfacesCl=cl.getInterfaces();
                     String modifiers=Modifier.toString(cl.getModifiers());
                     if(modifiers.length()>0){
                         System.out.print(modifiers+" ");
                     }
                     System.out.print("class "+name);

                     if(superCl!=null && superCl !=Object.class){
                         System.out.print(" extends "+superCl.getName());
                     }
                     for(int i=0;i<interfacesCl.length;i++){
                         if(i==0){
                             System.out.print(" implements ");
                         }
                         if(i>0){
                             System.out.print(",");
                         }
                         System.out.print(interfacesCl[i].getName());
                     }
                     System.out.print("\n{\n");
                     printConstructors(cl);
                     System.out.println();
                     printMethod(cl);
                     System.out.println();
                     pritField(cl);
                     System.out.println("}");
                 } catch (ClassNotFoundException e) {
                     e.printStackTrace();
                 }
             }
             /**
              * Prints all constructors of a class
              * @param cl
              */
             public static void printConstructors(Class cl){
                 Constructor[] constructors=cl.getConstructors();
                 for(Constructor c:constructors){
                     String name=c.getName();
                     System.out.print("    ");
                     String modifiers=Modifier.toString(c.getModifiers());
                     if(modifiers.length()>0){
                         System.out.print(modifiers+" ");
                     }
                     System.out.print(name+"(");

                     Class[] paramTypes=c.getParameterTypes();
                     for(int i=0;i<paramTypes.length;i++){
                         if(i>0){
                             System.out.print(",");
                         }
                         System.out.print(paramTypes[i].getName());
                     }
                     System.out.println(");");
                 }
             }

             /**
              * Prints all method of a class
              * @param cl
              */
             public static void printMethod(Class cl){
                 Method[] methods=cl.getMethods();
                 for(Method m:methods){
                     String name =m.getName();
                     System.out.print("    ");
                     String modifiers=Modifier.toString(m.getModifiers());
                     if(modifiers.length()>0){
                         System.out.print(modifiers+" ");
                     }
                     System.out.print(name+"(");
                     Class[] params=m.getParameterTypes();
                     for(int i=0;i<params.length;i++){
                         if(i>0){
                             System.out.print(",");
                         }
                         System.out.print(params[i].getName());
                     }
                     System.out.println(");");
                 }
             }

             public static void pritField(Class cl){
                 Field[] fields=cl.getFields();
                 for(Field field:fields){
                     String name=field.getName();
                     System.out.print("    ");
                     String str_fields=Modifier.toString(field.getModifiers());
                     if(str_fields.length()>0){
                         System.out.print(str_fields+" ");
                     }
                     System.out.println(name+";");
                 }
             }
         }

Result:

这里要注意有一点坑坑的，就是如果你的参数是个数组的话参数打印那里会出现奇怪的表达：

例如： byte[] --> [B