反射_通过反射获取类的完整结构

获取运行时类的属性

public class TestFields {
    /**
     * 获取运行时类属性
     */
    @Test
    public void test1(){
        //获取运行时类
        Class clazz = Person.class;
        //1、getFields()只能获取到运行时类及其父类中声明为public的属性
        Field[] fields = clazz.getFields();
        for (int i = 0; i < fields.length; i++) {
            System.out.println(fields[i]);
        }
        //2、getDeclaredFields()：能够获取运行时类本身中声明的所有属性
        Field[] fields1 = clazz.getDeclaredFields();
        for (Field f:fields1) {
            System.out.println(f.getName());
        }
    }

    /**
     * 权限修饰符，变量类型，变量名
     * 获取属性的各个部分的内容
     */
    @Test
    public void test2(){
        Class clazz = Person.class;
        Field[] fields = clazz.getDeclaredFields();
        for (Field f:fields) {
            //1、获取每个属性的权限修饰符
            int i = f.getModifiers();
            String str = Modifier.toString(i);
            System.out.print(str +" ");
            //2、获取每个属性的变量类型
            Class type = f.getType();
            System.out.print(type.getName()+" ");
            //3、获取每个属性的属性名
            System.out.println(f.getName());
        }
    }
}

获取运行时类的方法

public class TestMethods {
    /**
     * 获取运行时类的方法
     */
    @Test
    public void test1(){
        Class clazz = Person.class;
        //1、getMethods():获取运行时类及其父类中的所有声明为public的方法
        Method[] methods1 = clazz.getMethods();
        for (Method m:methods1) {
            System.out.print(m.getName()+" ");
        }
        System.out.println();
        //2、getDeclaredMethods()：获取运行时类本身声明的方法
        Method[] methods2 = clazz.getDeclaredMethods();
        for (Method m:methods2) {
            System.out.print(m.getName()+" ");
        }
    }

    /**
     * 注解、权限修饰符、返回值类型、方法名、形参列表、异常
     */
    @Test
    public void test2(){
        Class clazz = Person.class;

        Method[] methods = clazz.getDeclaredMethods();
        for (Method m:methods) {
            //1、注解
            Annotation[] annotations = m.getDeclaredAnnotations();
            for (Annotation a:annotations) {
                System.out.println(a);
            }

            //2、权限修饰符
            int i = m.getModifiers();
            String str = Modifier.toString(i);
            System.out.println(str);
            //3、返回值类型
            Class returnType = m.getReturnType();
            System.out.println(returnType.getName());
            //4、方法名
            System.out.println(m.getName()+" ");
            //5、形参列表
            Class[] parameters = m.getParameterTypes();
            for (Class c:parameters) {
                System.out.println(c.getName()+" args ");
            }
            //6、异常类型
            Class[] exceptionTypes = m.getExceptionTypes();
            for (Class excep:exceptionTypes) {
                System.out.println(excep.getName()+" exception");
            }

        }
    }

}

获取运行时类的构造器

public class TestConstructors {
    /**
     *  获取运行时类构造器
     */
    @Test
    public void test() throws ClassNotFoundException {
        //获取Class实例
        String className = "Progress.reflection.Person";
        Class clazz = Class.forName(className);
        //1、getConstructors():获取运行时类及其父类中的所有声明为public的方法
        Constructor[] constructors1 =  clazz.getConstructors();
        for (Constructor c:constructors1) {
            System.out.println(c.getName());
        }
        //2、getDeclaredConstructors()：获取运行时类本身声明的方法
        Constructor[] constructors2 =  clazz.getDeclaredConstructors();
        for (Constructor c:constructors2) {
            System.out.println(c.getName());
        }
    }
}

其他

public class TestOthers {
    /**
     * 获取运行时类的父类
     */
    @Test
    public void test1(){
        Class clazz = Person.class;
        //1、获取父类
        Class superClass = clazz.getSuperclass();
        System.out.println(superClass);
        //2、获取带泛型的父类
        Type genericSupperClass = clazz.getGenericSuperclass();
        System.out.println(genericSupperClass);
        //3、获取父类的泛型
        ParameterizedType type = (ParameterizedType) genericSupperClass;
        Type[] types = type.getActualTypeArguments();
        for (Type t:types) {
            System.out.println(t);
        }
    }

    /**
     * 获取实现接口
     */
    @Test
    public void test2(){
        Class clazz = Person.class;
        Class[] interfaces = clazz.getInterfaces();
        for (Class i:interfaces) {
            System.out.println(i);
        }
    }

    /**
     * 获取所在的包
     */
    @Test
    public void test3(){
        Class clazz = Person.class;
        Package p = clazz.getPackage();
        System.out.println(p);
    }
    /**
     * 获取注解
     */
    @Test
    public void test4(){
        Class clazz = Person.class;
        Annotation[] annotations = clazz.getAnnotations();
        for (Annotation a:annotations) {
            System.out.println(a);
        }
    }
}