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

一时失言乱红尘 2022-05-20 00:25 285阅读 0赞

#### 获取运行时类的属性 ####

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);
            }
        }
    }