java-reflect 常用方法说明及实例

Class类的使用  java.lang.Class

1.1在Java中，每个class都有一个相应的Class对象。也就是说，当我们编写一个类，编译完成后，在生成的.class文件中，就会产生一个Class对象，用于表示这个类的类型信息。

1.2获取Class实例方式

方法1

利用对象调用getClass()方法获取该对象的Class实例；

方法2

使用Class类的静态方法forName()， 用类的名字获取一个Class实例（staticClass forName(String className) Returns the Classobject associated with the class or interface with the given stringname. ）；

方法3

运用.class的方式来获取Class实例，对于基本数据类型的封装类，还可以采用.TYPE来获取相对应的基本数据类型的Class实例

在newInstance()调用类中缺省的构造方法 ObjectnewInstance()（可在不知该类的名字的时候，创建这个类的实例） Creates a new instance of the class represented by this Classobject.

在运行期间，如果我们要产生某个类的对象，Java虚拟机(JVM)会检查该类型的Class对象是否已被加载。如果没有被加载，JVM会根据类的名称找到.class文件并加载它。一旦某个类型的Class对象已被加载到内存，就可以用它来产生该类型的所有对象 [1]

打印类的类信息

      /**

      * 打印类的信息，包含类的成员函、数成员变量

      */

      public static void printClassMessage(Object obj) {

           // 要获取类的信息 首先要获取类的类类型c

           Class c = obj.getClass(); // 传递的是哪个子类的对象 c就是该子类的类类型

           // 获取类的名字

          System. out .println("类的名称是：" + c.getName());

           /*

           * Method类，方法对象 一个成员方法就是一个Method对象

           * getMethod方法()获取所有public的函数，包括父类继承而来的方法。

           * getDeclaredMethods()获取的是所有该类自己声明的方法，不问访问权限

           */

          Method[] ms = c.getDeclaredMethods();

           for (Method method : ms) {

               Class returnType = method.getReturnType();// 得到方法的返回值类型的类类型

              System. out .println(returnType.getName() + " ");

              System. out .print(method.getName());// 得到方法名称

              StringBuilder paramStr = new StringBuilder();

               Class[] paramTypes = method.getParameterTypes();// 获取参数类型-->得到的是参数列表的类型的类类型

               if (paramTypes != null && paramTypes. length > 0) {

                   paramStr.append( "(" );

                    for (Class type : paramTypes) {

                        paramStr.append(type.getName() + "," );

                   }

                   paramStr.deleteCharAt(paramStr.length() - 1);

                   paramStr.append( ")" );

              } else {

                   paramStr.append( "()" );

              }

              System. out .println(paramStr.toString());

               /*

               * 成员变量也是对象java.lang.reflect.Field Field类封装了关于成员变量的操作

               * getFields获取所有的public的成员变量的信息 getDeclaredFields()获取该类自己声明的成员变量的信息

               */

              Field[] fs = c.getDeclaredFields();

               if (fs != null && fs. length > 0) {

                    for (Field field : fs) {

                         // 得到成员变量的类型的类类型

                         Class fType = field.getType();

                        System. out .println(fType.getName() + ":" + field.getName());

                   }

              }

               /*

               * 构造函数也是对象 java.lang.Constructor中封装了构造函数的信息

               * c.getDeclaredConstructors() 得到所有自己声明的构造方法

               */

               Constructor[] cs = c.getDeclaredConstructors();

              System. out .println(cs.length );

               if (cs != null && cs. length > 0) {

                   StringBuilder csStr = new StringBuilder();

                    for (Constructor constructor : cs) {

                        csStr.append(constructor.getName());

                        csStr.append( "(" );

                         Class[] ctypes = constructor.getParameterTypes();

                         if (ctypes != null && ctypes.length > 0) {

                              for (Class type : ctypes) {

                                  csStr.append(type.getName() + "," );

                             }

                             csStr.deleteCharAt(csStr.length() - 1);

                        }

                        csStr.append( ")" );

                   }

                   System. out .println(csStr.toString());

              }

          }

     }

1.3方法的反射

  1）如何获取某个方法？

     方法名和方法的参数列表才能唯一的决定某个方法

  2）方法反射的操作

     method.invoke(对象，参数列表)

实例：

public   static  void  main(String[] args) {

            //如何获取指定print方法，1.要获取一个方法就是获取类的信息，获取类的信息首先要获取类的类对象

           Class c = A.  class ;

            /*

           *2.获取方法 名称和参数列表来决定唯一的方法

           *class...或者 int...等等 代表的意思是需要1个或多个参数，可以传递new Class[]{X,X,X}或者x,x,x这两种类型的参数

           *getMethod获取的是public的方法

           *getDeclaredMethod获取的是自己声明的方法

           */

            try  {

              Method method = c.getDeclaredMethod(  "print" ,  int .  class  ,  int .  class ) ;

              method.invoke(c.newInstance(), 1,1);  //方法的反射操作,通过方法来操作类去执行。

              

              Method method1 = c.getDeclaredMethod(  "print" ,  new  Class[]{String.  class  ,String. class  } ) ;

              method1.invoke(c.newInstance(),  "hello"  , "World"  ); //方法的反射操作,通过方法来操作类去执行。

          }  catch  (Exception e) {

              e.printStackTrace();

          }

     }

class  A {

     

       public   void  print( int  a,  int  b){

          System.  out  .println(a+b);

     }

     

       public   void  print(String a,String b){

          System.  out  .println(a+b);

     }

}

1.4通过反射了解集合泛型的本质

      List a =  new  ArrayList ();

           List<String> b =  new  ArrayList<String>();

          

           Class ca = a.getClass();

           Class cb = b.getClass();

            //看看list集合的类对象是否相同

          System.  out  .println(ca==cb);

            /*

           *返回结果为true,虽然2个集合的泛型不同，但是类的类对象相同

           *也说明Java中集合的泛型，是防止错误输入的只在编译阶段有效，绕过编译就无效了。

           *验证：方法的反射来操作，绕过编译

           */

            try  {

              Method m = cb.getMethod(  "add" , Object. class  );

              m.invoke(b, 100);

              System.  out  .println(b.size());

              System.  out  .println(b);

                for  ( int  i = 0; i < b.size(); i++) {

                   Object obj = b.get(i);

                   System.  out  .println(obj);

              }

          }  catch  (Exception e) {

              e.printStackTrace();

          }