反射之获取方法信息

Posted 2020-09-21 Format_all

 

本文接上文“Class类的使用”，以编写一个用来获取类的信息（成员函数、成员变量、构造函数）的工具类来讲解"反射之获取类的信息"

1、获取成员函数信息

 1 /**
 2  * 获取成员函数信息
 3  * @param obj
 4  */
 5 public static void printClassMethodMessage(Object obj){
 6     //获取类的信息   获取类的类类型
 7     Class c = obj.getClass();
 8     //获取类的名称
 9     System.out.println("类的名称是：" + c.getName());
10     /**
11      * Methods类，方法对象
12      * 一个成员方法就是一个Method对象
13      * getMethods()方法是获取所有public的函数，包括父类继承而来
14      * getDeclaredMethods()获取的是所有该类自己声明的方法，不问访问权限
15      */
16 //  Method [] ms = c.getMethods();
17     Method [] ms = c.getDeclaredMethods();
18     for (Method m : ms) {
19         //得到方法返回值的类类型
20         Class returnType = m.getReturnType();
21         System.out.print(returnType.getName() + " ");
22         //得到方法名称
23         System.out.print(m.getName() + "(");
24         //获取参数类型(得到的是参数列表的类型的类类型)
25         Class[] paramTypes = m.getParameterTypes();
26         for (Class paramType : paramTypes) {
27             System.out.print(paramType.getName()+",");
28         }
29         System.out.println(")");
30     }
31 }

2、获取成员变量信息

 1 /**
 2  * 获取成员变量信息
 3  * @param obj
 4  */
 5 public static void printClassFieldMessage(Object obj) {
 6     Class c = obj.getClass();
 7     /**
 8      * 成员变量也是对象
 9      * Field类封装了关于成员变量的操作
10      * getFields()获取的是所有的public的成员变量信息
11      * getDeclaredFields()获取的是该类自己声明的成员变量信息
12      */
13 //        Field [] fs = c.getFields();
14     Field[] fs = c.getDeclaredFields();
15     for (Field f : fs) {
16         //得到成员变量的类型的类类型
17         Class fieldType = f.getType();
18         String typeName = fieldType.getName();
19         //得到成员变量的名称
20         String fieldName = f.getName();
21         System.out.println(typeName+" "+fieldName);
22     }
23 }

3、获取构造函数信息

 1 public static void printConMessage(Object obj){
 2     Class c = obj.getClass();
 3     /**
 4      * 构造函数也是对象
 5      * java.lang.Constructor封装了构造函数的信息
 6      * getConstructors()获取所有的public构造函数
 7      * getDeclaredConstructors()获取所有的构造函数
 8      */
 9 //        Constructor[] cs = c.getConstructors();
10     Constructor[] cs = c.getDeclaredConstructors();
11     for (Constructor constructor : cs) {
12         System.out.print(constructor.getName()+"(");
13         //获取构造函数的参数列表,得到的是参数列表的类类型
14         Class[] paramTypes = constructor.getParameterTypes();
15         for (Class paramType : paramTypes) {
16             System.out.print(paramType.getName()+",");
17         }
18         System.out.println(")");
19     }
20 }

4、工具类代码

 1 package com.format.util;
 2 
 3 import java.lang.reflect.Constructor;
 4 import java.lang.reflect.Field;
 5 import java.lang.reflect.Method;
 6 
 7 /**
 8  * 打印类的信息，成员函数、成员变量
 9  * Created by Format on 2017/6/3.
10  */
11 public class ClassUtil {
12 
13     /**
14      * 获取成员函数信息
15      * @param obj
16      */
17     public static void printClassMethodMessage(Object obj){
18         //获取类的信息   获取类的类类型
19         Class c = obj.getClass();
20         //获取类的名称
21         System.out.println("类的名称是：" + c.getName());
22         /**
23          * Methods类，方法对象
24          * 一个成员方法就是一个Method对象
25          * getMethods()方法是获取所有public的函数，包括父类继承而来
26          * getDeclaredMethods()获取的是所有该类自己声明的方法，不问访问权限
27          */
28 //        Method [] ms = c.getMethods();
29         Method [] ms = c.getDeclaredMethods();
30         for (Method m : ms) {
31             //得到方法返回值的类类型
32             Class returnType = m.getReturnType();
33             System.out.print(returnType.getName() + " ");
34             //得到方法名称
35             System.out.print(m.getName() + "(");
36             //获取参数类型(得到的是参数列表的类型的类类型)
37             Class[] paramTypes = m.getParameterTypes();
38             for (Class paramType : paramTypes) {
39                 System.out.print(paramType.getName()+",");
40             }
41             System.out.println(")");
42         }
43     }
44 
45     /**
46      * 获取成员变量信息
47      * @param obj
48      */
49     public static void printClassFieldMessage(Object obj) {
50         Class c = obj.getClass();
51         /**
52          * 成员变量也是对象
53          * Field类封装了关于成员变量的操作
54          * getFields()获取的是所有的public的成员变量信息
55          * getDeclaredFields()获取的是该类自己声明的成员变量信息
56          */
57 //        Field [] fs = c.getFields();
58         Field[] fs = c.getDeclaredFields();
59         for (Field f : fs) {
60             //得到成员变量的类型的类类型
61             Class fieldType = f.getType();
62             String typeName = fieldType.getName();
63             //得到成员变量的名称
64             String fieldName = f.getName();
65             System.out.println(typeName+" "+fieldName);
66         }
67     }
68 
69     /**
70      * 获取构造函数信息
71      * @param obj
72      */
73     public static void printConMessage(Object obj){
74         Class c = obj.getClass();
75         /**
76          * 构造函数也是对象
77          * java.lang.Constructor封装了构造函数的信息
78          * getConstructors()获取所有的public构造函数
79          * getDeclaredConstructors()获取所有的构造函数
80          */
81 //        Constructor[] cs = c.getConstructors();
82         Constructor[] cs = c.getDeclaredConstructors();
83         for (Constructor constructor : cs) {
84             System.out.print(constructor.getName()+"(");
85             //获取构造函数的参数列表,得到的是参数列表的类类型
86             Class[] paramTypes = constructor.getParameterTypes();
87             for (Class paramType : paramTypes) {
88                 System.out.print(paramType.getName()+",");
89             }
90             System.out.println(")");
91         }
92     }
93 
94 }

View Code