反射（2）—通过反射获取属性方法等信息

• 使用反射机制，获取所有的属性（熟悉）和后者获取指定属性（掌握）
  
  • 获取权限修饰符
  • 获取变量类型
  • 获取变量名
  • 获取属性各部分的内容

public class TestField {
    /**
     * 1.使用反射获取运行时类的所有属性信息
     */
    @Test
    public void test1(){
        Class clazz = Person.class;
        //该方法只能获取运行时类中及其父类中声明的public修饰的属性
        Field[] fields1 = clazz.getFields();
        for(int i = 0;i < fields1.length;i++){
            System.out.println("getFields获取属性："+fields1[i].getName());
        }
        //该方法可以获取运行时类本身声明的所有属性
        Field[] fields2 = clazz.getDeclaredFields();
        for(int i = 0;i < fields2.length;i++){
            System.out.println("getDeclaredFields获取属性："+fields2[i].getName());
        }
    }
    /**
     * 2。获取所有的权限修饰符、变量类型、变量名，获取属性各部分的内容
     */
    @Test
    public void test2(){
        Class clazz = Person.class;
        //该方法可以获取运行时类本身声明的所有属性
        Field[] fields2 = clazz.getDeclaredFields();
        for(Field f : fields2){
            //1.获得每个的属性的权限修饰符
            int i = f.getModifiers(); 
            String str = Modifier.toString(i);
            System.out.print("访问权限"+str+" ");//输出权限修饰
            //2.获得属性的类型
            Class type = f.getType();
            System.out.println(type.getName()+" ");
            //3.获取属性名
            System.out.println("获取属性名:"+f.getName()+" ");
            System.out.println();//换行
        }
    }
    /**
     * 3.获取运行时类指定的属性(掌握)，同样的不能直接获取声明为private的属性
     *获取指定属性的两种方法
     *其一使用getField("name")，
     *其二使用getDeclaredField("age")，并设置age.setAccessible(true);
     */
    @Test
    public void test3() throws Exception{
        Class clazz = Person.class;
        //1.获取指定的属性
        Field name = clazz.getField("name");//此处抛异常，因为可能没有这个属性，该属性声明为public 
        //Field age = clazz.getField("age");//此处抛异常，因为该属性声明为private
        Field age = clazz.getDeclaredField("age");//使用这个方法可以获得所有声明的方法
        age.setAccessible(true);
        //2.创建运行时类的对象
        Person p = (Person)clazz.newInstance();
        System.out.println(p);
        //3.将运行时类指定的属性赋值
        name.set(p, "Ann");
        age.set(p, 21);
        System.out.println(p);

    }

    /**
     * 4.
     */
    @Test
    public static Object getSuperGenericType(Class clazz){

        return clazz.getGenericSuperclass();
    }




}

• 获取运行时类的方法信息(熟悉)和获取指定的方法(掌握)
  
  • 获取方法的完整结构
  • 获取注解
  • 获取权限修饰符
  • 获取返回值类型
  • 获取方法名
  • 获取形参列表
  • 获取异常

public class TestMethod {
    /**
     *可以获取包括父类在内的所有的使用public修饰的方法，甚至是Object类的方法也可以获取，
     *private修饰的方法获取不到 
     */
    @Test
    public void test1(){
        Class clazz = Person.class;
        //1.getMethod()方法可以获取运行时类的及其父类中所有声明为public的方法
        Method[] m1 = clazz.getMethods();
        for(Method m : m1){
            System.out.println(m);
        }
        System.out.println();
        //2.getDeclaredMethods()可以获取所有声明了的方法，但是只能获取运行时类自己的方法
        Method[] m2 = clazz.getDeclaredMethods();
        for(Method m : m2){
            System.out.println(m);
        }
        System.out.println();
    }
    /**
     * 获取方法的完整结构，注解、权限修饰符、返回值类型、方法名、形参列表、异常
     */
    @Test
    public void test2(){
        Class clazz = Person.class;
        Method[] m1 = clazz.getDeclaredMethods();//首先获取所有的方法
        for(Method m : m1){                      //循环每个方法
            //1.注解
            Annotation[] ann = m.getAnnotations();//获得每个方法的一些属性
            for(Annotation a : ann){
                System.out.println(a);              
            }
            //2.权限修饰符
            String str = Modifier.toString(m.getModifiers());
            System.out.print(str+" ");
            //3.返回值类型
            Class returnType = m.getReturnType();
            System.out.print(returnType.getName()+" ");
            //4.方法名
            System.out.print(m.getName()+" ");
            //5.形参列表
            System.out.print("(");
            Class[] parmas = m.getParameterTypes();//形参有多个，所有返回的是一个形参的类型
            for(int i = 0; i < parmas.length;i++){
                System.out.print(parmas[i].getName()+" args"+i+" ");
            }
            System.out.print(")");
            //6.异常类型
            Class[] ex = m.getExceptionTypes();
            if(ex.length != 0){
                System.out.print("throws ");
            }
            for(int i = 0; i < ex.length; i++){
                System.out.print(ex[i].getName()+" ");
            }

            System.out.println();

        }

    }
    /**
     * 获知运行时类指定的方法
     * 1.获取public void show()，无返回值，成功
     * 2.获取public String toString()，有返回值，成功
     * 3.获取private void display (String nation)，访问权限不一样，含有参数列表，
     * 失败，因为private,需要使用m2.setAccessible(true);
     * 4.获取指定的静态方法
     * 5.获取指定构造方法
     *调用方法使用invoke()
     */
    @Test
    public void test() throws Exception{
        Class clazz = Person.class;
        //1.获取方法show()
        //获得指定方法
        Method m = clazz.getMethod("show");//指定方法名和形参，形参没有就不写
        //创建对象调用方法
        Person p =(Person)clazz.newInstance();  
        //参数为对象和方法的形参，该方法拥有返回值，返回值为所调方法的返回值
        Object resultValue = m.invoke(p);//打印show方法的输出结果：我是一个人
        System.out.println(resultValue);//打印NULL
        //2.获取方法toString()
        Method m1 = clazz.getMethod("toString");
        Object resultValu1 = m1.invoke(p);//无结果
        System.out.println(resultValu1);//打印Person [name=null, age=0]
        //3.获取方法display()，获取不到，该方法访问标权限为private，需要使用setAccessible(true);
        Method m2 = clazz.getDeclaredMethod("display",String.class);
        m2.setAccessible(true);
        Object ob = m2.invoke(p,"China");//打印国籍是China
        System.out.println(ob);//打印1
        //4.获取静态方法
        Method m3 = clazz.getMethod("info",int.class,float.class);
        m3.invoke(Person.class,1,1.1f);//打印传进来的参数是：1 1.1
        //5.调用指定的构造器
        Constructor m4 = clazz.getDeclaredConstructor(String.class,int.class);
        m4.setAccessible(true);
        Person p1 = (Person)m4.newInstance("李斯",32);
        System.out.println(p1);//打印Person [name=李斯, age=32]
    }
}

• 获取到方法之后就可以利用反射去调用执行

//利用反射获取methodName方法
Method method =getClass().getDeclaredMethod(methodName,HttpServletRequest.class, 
HttpServletResponse.class);
//System.out.println("反射获取的方法："+method);
//利用反射调用名称为method的方法
method.invoke(this, request,response)

• 获取父类信息
  
  • 获取父类
  • 获取带泛型的父类
  • 获取父类的泛型，重要
  • 获取实现的接口
  • 获取所在是包
  • 获取运行时类的注解，若注解的生命周期改成class就无法获取到

public class TestOthers {

    //1.获取父类
    @Test
    public void test(){
        Class clazz = Person.class;
        Class superClass = clazz.getSuperclass();
        System.out.println(superClass);
    }

    //2.获取带泛型的父类
    @Test
    public void test1(){
        Class clazz = Person.class;
        Type t = clazz.getGenericSuperclass();
        System.out.println(t);
    }

    //3.获取父类的泛型，重要
        @Test
        public void test2(){
            Class clazz = Person.class;
            Type t = clazz.getGenericSuperclass();
            ParameterizedType param = (ParameterizedType)t;
            Type[] type = param.getActualTypeArguments();
            System.out.println(((Class)type[0]).getName());
        }

        //4.获取实现的接口
        @Test 
        public void test3(){
            Class clazz = Person.class;
            Package p = clazz.getPackage();
            System.out.println(p);
        }

        //5.获取所在是包
        @Test 
        public void test4(){
            Class clazz = Person.class;
            Class[] c = clazz.getInterfaces();
            for(Class i : c){
                System.out.println(i);
            }
        }

        //5.获取运行时类的注解，若注解的生命周期改成class就无法获取到
        @Test 
        public void test5(){
            Class clazz = Person.class;
            Annotation[] anno = clazz.getAnnotations();
            for(Annotation i : anno){
                System.out.println(i);
            }
        }


}