反射分析类

1. 前言

在程序运行期间，Java运算时系统为所有的对象维护一个呗称为运行时的类型标识，这个信息跟踪这每个对象所属的类。保持这些信息的类被称为Class。

2. 获取Class对象方法

2.1.使用实例对象获取Class类

Employee e;
Class cls = e.getClass();

2. 使用类名称获取

Class cls = Class.forName("employee.Employee");

2.2 Class类常用方法

3. 反射

反射库提供了一个非常丰富的工具集，一遍编写可以动态操作的Java代码的程序。反射是一种功能强大且复杂的机制，可以用来

• 在运行时分析类的能力。
• 在运行时查看对象的能力，如编写一个toString方法供所有类使用。
• 实现统一的数组操作代码。
• 利用Method对象。

3.1 利用反射分析类

java.lang.reflect包中有三类Field, Method, Constructor分别用于描述类的域，方法和构造器。
这个三个类包含一个方法getName() 获取项目名称，还包含一个getModifiers()方法获取修饰符
java.lang.freflect包中还有一个Modifier类，

Modifier类

使用getModifiers()返回一个整数，这个整数用来表示修饰符，这个整数的每bit表示一个修饰符，其定义如下：

    /**
     * The {@code int} value representing the {@code public}
     * modifier.
     */
    public static final int PUBLIC           = 0x00000001;

    /**
     * The {@code int} value representing the {@code private}
     * modifier.
     */
    public static final int PRIVATE          = 0x00000002;

    /**
     * The {@code int} value representing the {@code protected}
     * modifier.
     */
    public static final int PROTECTED        = 0x00000004;

    /**
     * The {@code int} value representing the {@code static}
     * modifier.
     */
    public static final int STATIC           = 0x00000008;

我们不需要去记忆这值定义，可以使用 Modifier.toString()方法将该整数转换为字符串，如下所示：

Modifier.toString(f.getModifiers()); 

3.2 使用反射分析类的域

3.2.1 反射包Field类常用方法

3.2.2 demo

类的域定下如下：修饰符 类型 域名；
使用上述方法可以很方便的获取类的域，见如下代码:

 public class FieldReflectionTest {
    public static void main(String[] args) {
        FieldReflectionTest demo = new FieldReflectionTest();
        String className = "employee.Employee";
        try {
            Class cls = Class.forName(className);
            String modifiers = Modifier.toString(cls.getModifiers());
            if (modifiers.length() > 0) {
                System.out.println(modifiers + " ");
            }
            System.out.println("class " + className);
            System.out.println("\n\n");
            printField(cls);
            printMethod(cls);
            printConstructors(cls);
        }catch (ClassNotFoundException e){
            e.printStackTrace();
        }
    }
    public static void printField(Class<?> cls) {
        System.out.println("Print field: \n");
        try {
            Field[] fields = cls.getDeclaredFields();                   //获取所有的类声明域，返回Field类对象数组
            for (Field f : fields) {
                Class type = f.getType();                               //获取类域的类型
                String name = f.getName();                              //获取类域的名称
                System.out.println("\n");
                String modifiers = Modifier.toString(f.getModifiers()); //获取类域修饰符
                System.out.println(modifiers + " " + type.getName() + " " + name + ";");

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

}

3.3 使用反射Method类 分析类的方法

3.3.1Method类常用方法

3.3.2 demo

方法定义如下： 修饰符 返回值类型 名称（参数）

 public static void printMethod(Class<?> cls)
    {
        System.out.println("Print Methods: \n");
        Method[] methods = cls.getDeclaredMethods();
        for (Method m : methods){
            StringBuilder methodProtypeSB = new StringBuilder();
            Class retType = m.getReturnType();
            String name = m.getName();

            String modifier = Modifier.toString(m.getModifiers());
            if (modifier.length() > 0){
                methodProtypeSB.append(modifier);           //获取修饰符
            }
            methodProtypeSB.append(" ");                    //增加空格
            methodProtypeSB.append(retType.getName());      //获取返回类型
            methodProtypeSB.append(" ");                    //增加空格
            methodProtypeSB.append(name);                   //获取方法名称
            methodProtypeSB.append("(");                    //获取左括号
            Class[] paramTypes = m.getParameterTypes();
            for (int i = 0; i < paramTypes.length; i++){
                if (i > 0) {
                    methodProtypeSB.append(",");            //参数分隔符
                }
                methodProtypeSB.append(paramTypes[i].getName());        //获取参数类型
            }
            methodProtypeSB.append(");");
            System.out.println(methodProtypeSB.toString());
        }
    }

3.4 使用反射包Constructor类分析类构造函数

3.4.1 Constructor类常用方法

3.4.2 demo

public static void printConstructors(Class cls){

        System.out.println("Printf constructors: \n");
        Constructor[] constructors = cls.getDeclaredConstructors();
        for (Constructor c : constructors){
            StringBuilder sb = new StringBuilder();
            String name = c.getName();
            String modifiers = Modifier.toString(c.getModifiers());
            if (modifiers.length() > 0){                //获取修饰符
                sb.append(modifiers);
                sb.append(" ");                         //增加空格
            }
            sb.append(name);                            //获取构造函数名字
            sb.append("(");
            Class[] paramTypes = c.getParameterTypes(); //获取参数类型
            for (int i = 0; i < paramTypes.length; i++) {
                if (i > 0) {
                    sb.append(",");                     //增加参数分隔符
                }
                sb.append(paramTypes[i].getName());
            }
            sb.append(");");
            System.out.println(sb.toString());
        }
    }

4. 我的公众号

专注分享嵌入式开发，andriod开发原创文章。

5. 鼓励作者

如果本文对您有帮助，请打赏鼓励下。