java反射调用运行时类的结构

你的名字 2022-10-05 04:45 184阅读 0赞

### java反射调用运行时类的结构 ###

*  需要操作的对象
 *   *  需要自定义的注解
 *  一、调用运行时类的指定属性
 *   *  1. 获取属性结构
     *  2、权限修饰符 数据类型 变量名
 *  二、调用运行时类的指定方法
 *   *  1. 获取指定方法
     *  2、权限修饰符 返回值类型 方法名(参数类型1 形参名1,...) throws XxxException\{\}
 *  调用运行时类的指定构造器
 *   *  1、获取构造器结构
     *  2、获取运行时类的父类
     *  3、 获取运行时类的带泛型的父类
     *  4、 获取运行时类的带泛型的父类的泛型
     *  5、 获取运行时类实现的接口
     *  6、获取运行时类所在的包
     *  7、获取运行时类声明的注解

# 需要操作的对象 #

@MyAnnotation(value="hi")
    public class Person extends Creature<String> implements Comparable<String>,MyInterface{ 
    
        private String name;
        int age;
        public int id;
    
        public Person(){ }
    
        @MyAnnotation(value="abc")
        private Person(String name){ 
            this.name = name;
        }
    
         Person(String name,int age){ 
            this.name = name;
            this.age = age;
        }
        @MyAnnotation
        private String show(String nation){ 
            System.out.println("我的国籍是：" + nation);
            return nation;
        }
    
        public String display(String interests,int age) throws NullPointerException,ClassCastException{ 
            return interests + age;
        }
    
    
        @Override
        public void info() { 
            System.out.println("我是一个人");
        }
    
        @Override
        public int compareTo(String o) { 
            return 0;
        }
    
        private static void showDesc(){ 
            System.out.println("我是一个可爱的人");
        }
    
        @Override
        public String toString() { 
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", id=" + id +
                    '}';
        }
    }

## 需要自定义的注解 ##

@Target({ TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyAnnotation { 
        String value() default "hello";
    
    }

# 一、调用运行时类的指定属性 #

## 1. 获取属性结构 ##

@Test
        public void test1(){ 
    
            Class clazz = Person.class;
    
            //获取属性结构
            //getFields():获取当前运行时类及其父类中声明为public访问权限的属性
            Field[] fields = clazz.getFields();
            for(Field f : fields){ 
                System.out.println(f);
            }
            System.out.println();
    
            //getDeclaredFields():获取当前运行时类中声明的所有属性。（不包含父类中声明的属性）
            Field[] declaredFields = clazz.getDeclaredFields();
            for(Field f : declaredFields){ 
                System.out.println(f);
            }
        }

## 2、权限修饰符 数据类型 变量名 ##

@Test
        public void test2(){ 
            Class clazz = Person.class;
            Field[] declaredFields = clazz.getDeclaredFields();
            for(Field f : declaredFields){ 
                //1.权限修饰符
                int modifier = f.getModifiers();
                System.out.print(Modifier.toString(modifier) + "\t");
    
                //2.数据类型
                Class type = f.getType();
                System.out.print(type.getName() + "\t");
    
                //3.变量名
                String fName = f.getName();
                System.out.print(fName);
    
                System.out.println();
            }
    
        }

# 二、调用运行时类的指定方法 #

## 1. 获取指定方法 ##

@Test
        public void test1(){ 
    
            Class clazz = Person.class;
    
            //getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
            Method[] methods = clazz.getMethods();
            for(Method m : methods){ 
                System.out.println(m);
            }
            System.out.println();
            //getDeclaredMethods():获取当前运行时类中声明的所有方法。（不包含父类中声明的方法）
            Method[] declaredMethods = clazz.getDeclaredMethods();
            for(Method m : declaredMethods){ 
                System.out.println(m);
            }
        }

## 2、权限修饰符 返回值类型 方法名(参数类型1 形参名1,…) throws XxxException\{\} ##

@Test
        public void test2(){ 
            Class clazz = Person.class;
            Method[] declaredMethods = clazz.getDeclaredMethods();
            for(Method m : declaredMethods){ 
                //1.获取方法声明的注解
                Annotation[] annos = m.getAnnotations();
                for(Annotation a : annos){ 
                    System.out.println(a);
                }
    
                //2.权限修饰符
                System.out.print(Modifier.toString(m.getModifiers()) + "\t");
    
                //3.返回值类型
                System.out.print(m.getReturnType().getName() + "\t");
    
                //4.方法名
                System.out.print(m.getName());
                System.out.print("(");
                //5.形参列表
                Class[] parameterTypes = m.getParameterTypes();
                if(!(parameterTypes == null && parameterTypes.length == 0)){ 
                    for(int i = 0;i < parameterTypes.length;i++){ 
    
                        if(i == parameterTypes.length - 1){ 
                            System.out.print(parameterTypes[i].getName() + " args_" + i);
                            break;
                        }
    
                        System.out.print(parameterTypes[i].getName() + " args_" + i + ",");
                    }
                }
    
                System.out.print(")");
    
                //6.抛出的异常
                Class[] exceptionTypes = m.getExceptionTypes();
                if(exceptionTypes.length > 0){ 
                    System.out.print("throws ");
                    for(int i = 0;i < exceptionTypes.length;i++){ 
                        if(i == exceptionTypes.length - 1){ 
                            System.out.print(exceptionTypes[i].getName());
                            break;
                        }
    
                        System.out.print(exceptionTypes[i].getName() + ",");
                    }
                }
    
    
                System.out.println();
            }
    
    
    
        }

# 调用运行时类的指定构造器 #

## 1、获取构造器结构 ##

@Test
        public void test1(){ 
    
            Class clazz = Person.class;
            //getConstructors():获取当前运行时类中声明为public的构造器
            Constructor[] constructors = clazz.getConstructors();
            for(Constructor c : constructors){ 
                System.out.println(c);
            }
    
            System.out.println();
            //getDeclaredConstructors():获取当前运行时类中声明的所有的构造器
            Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
            for(Constructor c : declaredConstructors){ 
                System.out.println(c);
            }
    
        }

## 2、获取运行时类的父类 ##

@Test
        public void test2(){ 
            Class clazz = Person.class;
    
            Class superclass = clazz.getSuperclass();
            System.out.println(superclass);
        }

## 3、 获取运行时类的带泛型的父类 ##

@Test
        public void test3(){ 
            Class clazz = Person.class;
    
            Type genericSuperclass = clazz.getGenericSuperclass();
            System.out.println(genericSuperclass);
        }

## 4、 获取运行时类的带泛型的父类的泛型 ##

代码：逻辑性代码 vs 功能性代码

@Test
        public void test4(){ 
            Class clazz = Person.class;
    
            Type genericSuperclass = clazz.getGenericSuperclass();
            ParameterizedType paramType = (ParameterizedType) genericSuperclass;
            //获取泛型类型
            Type[] actualTypeArguments = paramType.getActualTypeArguments();
    // System.out.println(actualTypeArguments[0].getTypeName());
            System.out.println(((Class)actualTypeArguments[0]).getName());
        }

## 5、 获取运行时类实现的接口 ##

@Test
        public void test5(){ 
            Class clazz = Person.class;
    
            Class[] interfaces = clazz.getInterfaces();
            for(Class c : interfaces){ 
                System.out.println(c);
            }
    
            System.out.println();
            //获取运行时类的父类实现的接口
            Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
            for(Class c : interfaces1){ 
                System.out.println(c);
            }
    
        }

## 6、获取运行时类所在的包 ##

@Test
        public void test6(){ 
            Class clazz = Person.class;
    
            Package pack = clazz.getPackage();
            System.out.println(pack);
        }

## 7、获取运行时类声明的注解 ##

@Test
        public void test7(){ 
            Class clazz = Person.class;
    
            Annotation[] annotations = clazz.getAnnotations();
            MyAnnotation declaredAnnotation = (MyAnnotation) clazz.getDeclaredAnnotation(MyAnnotation.class);
            System.out.println(declaredAnnotation.value());
            for(Annotation annos : annotations){ 
                System.out.println(annos);
            }
        }
    
    }