打印类与对象字段、方法

做代码分析，一般需要
1、类的继承关系
2、类的静态变量、静态方法
3、类的实例变量、实例方法
idea 自带的Diagrams可以帮助分析类的继承关系、变量、方法。但是无法区分是静态还是实例的。因此可以利用反射，统计下该类信息。

1 类信息

1.1 类变量

    public static void printStaticFields(Class classType) {
        // getDeclaredFields可以获得所有字段,getFields()只能获得public的变量
        Field[] declaredFields = classType.getDeclaredFields();
        Map<String, List<Field>> map = new HashMap<>();

        // 遍历
        for (Field field : declaredFields) {
            int modifiers = field.getModifiers();
            // static修饰的是类变量
            if (Modifier.isStatic(modifiers)) {
                // 私有变量,只有自身能访问
                if (Modifier.isPrivate(modifiers)) {
                    put(map, field, "private");
                    // 可继承的变量，可被自身和继承类访问
                } else if (Modifier.isProtected(modifiers)) {
                    put(map, field, "protected");
                    // 公共变量,全局可访问
                } else if (Modifier.isPublic(modifiers)) {
                    put(map, field, "public");
                    // 包内可访问变量
                } else {
                    put(map, field, "package");
                }
            }
        }

        // 打印
        for (Map.Entry<String, List<Field>> entry : map.entrySet()) {
            String key = entry.getKey();
            System.out.println("=========" + key + "==========");
            List<Field> list = entry.getValue();
            list.stream().forEach(System.out::println);
            System.out.println();
        }

    }

    private static void put(Map<String, List<Field>> map, Field field, String type) {
        List<Field> list = map.get(type);
        if ( list == null) {
            list = new ArrayList<>();
            map.put(type, list);
        }
        list.add(field);
    }

    public static void main(String[] args) {
        printStaticFields(Thread.class);
    }

1.2 类方法

    public static void printStaticMethods(Class classType) {
        // getDeclaredMethods可以获得所有方法,getMethods()只能获得public的方法
        Method[] declaredMethods = classType.getDeclaredMethods();
        Map<String, List<Method>> map = new HashMap<>();

        // 遍历
        for (Method method : declaredMethods) {
            int modifiers = method.getModifiers();
            // static修饰的是类方法
            if (Modifier.isStatic(modifiers)) {
                // 私有方法,只有自身能访问
                if (Modifier.isPrivate(modifiers)) {
                    put(map, method, "private");
                    // 可继承的方法，可被自身和继承类访问
                } else if (Modifier.isProtected(modifiers)) {
                    // 可继承的变量，可被自身和继承类访问
                    put(map, method, "protected");
                    // 公共方法,全局可访问
                } else if (Modifier.isPublic(modifiers)) {
                    put(map, method, "public");
                    // 包内可访问方法
                } else {
                    put(map, method, "package");
                }
            }
        }

        // 打印
        for (Map.Entry<String, List<Method>> entry : map.entrySet()) {
            String key = entry.getKey();
            System.out.println("=========" + key + "==========");
            List<Method> list = entry.getValue();
            list.stream().forEach(System.out::println);
            System.out.println();
        }

    }

    private static void put(Map<String, List<Method>> map, Method method, String type) {
        List<Method> list = map.get(type);
        if ( list == null) {
            list = new ArrayList<>();
            map.put(type, list);
        }
        list.add(method);
    }

    public static void main(String[] args) {
        printStaticMethods(Thread.class);
    }

2 实例

不是static的就是实例变量或方法
!Modifier.isStatic(modifiers)

2.1 实例变量

    public static void printNonStaticFields(Class classType) {
        // getDeclaredFields可以获得所有字段,getFields()只能获得public的变量
        Field[] declaredFields = classType.getDeclaredFields();
        Map<String, List<Field>> map = new HashMap<>();

        // 遍历
        for (Field field : declaredFields) {
            int modifiers = field.getModifiers();
            // 非static修饰的是实例变量
            if (Modifier.isStatic(modifiers)) {
                // 私有变量,只有自身能访问
                if (Modifier.isPrivate(modifiers)) {
                    put(map, field, "private");
                    // 可继承的变量，可被自身和继承类访问
                } else if (Modifier.isProtected(modifiers)) {
                    put(map, field, "protected");
                    // 公共变量,全局可访问
                } else if (Modifier.isPublic(modifiers)) {
                    put(map, field, "public");
                    // 包内可访问变量
                } else {
                    put(map, field, "package");
                }
            }
        }

        // 打印
        for (Map.Entry<String, List<Field>> entry : map.entrySet()) {
            String key = entry.getKey();
            System.out.println("=========" + key + "==========");
            List<Field> list = entry.getValue();
            list.stream().forEach(System.out::println);
            System.out.println();
        }

    }

    private static void put(Map<String, List<Field>> map, Field field, String type) {
        List<Field> list = map.get(type);
        if ( list == null) {
            list = new ArrayList<>();
            map.put(type, list);
        }
        list.add(field);
    }

    public static void main(String[] args) {
        printNonStaticFields(Thread.class);
    }

2.2 实例方法

    public static void printNonStaticMethods(Class classType) {
        // getDeclaredMethods可以获得所有方法,getMethods()只能获得public的方法
        Method[] declaredMethods = classType.getDeclaredMethods();
        Map<String, List<Method>> map = new HashMap<>();

        // 遍历
        for (Method method : declaredMethods) {
            int modifiers = method.getModifiers();
            // 非static修饰的是实例方法
            if (Modifier.isStatic(modifiers)) {
                // 私有方法,只有自身能访问
                if (Modifier.isPrivate(modifiers)) {
                    put(map, method, "private");
                    // 可继承的方法，可被自身和继承类访问
                } else if (Modifier.isProtected(modifiers)) {
                    // 可继承的变量，可被自身和继承类访问
                    put(map, method, "protected");
                    // 公共方法,全局可访问
                } else if (Modifier.isPublic(modifiers)) {
                    put(map, method, "public");
                    // 包内可访问方法
                } else {
                    put(map, method, "package");
                }
            }
        }

        // 打印
        for (Map.Entry<String, List<Method>> entry : map.entrySet()) {
            String key = entry.getKey();
            System.out.println("=========" + key + "==========");
            List<Method> list = entry.getValue();
            list.stream().forEach(System.out::println);
            System.out.println();
        }

    }

    private static void put(Map<String, List<Method>> map, Method method, String type) {
        List<Method> list = map.get(type);
        if ( list == null) {
            list = new ArrayList<>();
            map.put(type, list);
        }
        list.add(method);
    }

    public static void main(String[] args) {
        printNonStaticMethods(Thread.class);
    }