四、通过反射获取运行时类的方法

测试类

package com.liaoxiang.java1;

@MyAnnotation(value="rose")
public class Person extends Creature<String> implements Comparable,MyInterface{
    public String name;
    private Integer age;
    int id;
	//省略getter、settter
    public Person() {
        System.out.println("调用了Person的空参构造器");
    }
    public Person(String name){
        this.name = name;
    }
    private Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                '}';
    }
    @Override
    public int compareTo(Object o) {
        return 0;
    }
    @MyAnnotation(value = "jack")
    public void show(){
        System.out.println("我是一个人！");
    }
    private Integer display(String nation, Integer i) throws Exception{
        System.out.println("我的国籍是："+ nation);
        return i;
    }
    public static void info(){
        System.out.println("静态方法：我是一个中国人");
    }
    // 内部类
    class Bird{}
}

自定义注解：

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

public class TestMethod {
    /**
     * 获取运行时类的方法
     *          getMethods(): 获取运行时类及其父类中声明为public的方法
     *  getDeclaredMethods(): 获取本类中的声明的所有方法
     */
    @Test
    public void test1(){
        Class<Person> personClass = Person.class;
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("======获取本身类的所有方法=======");
        Method[] declaredMethods = personClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }
        输出：
        ======获取本身类的所有方法=======
		public java.lang.String com.liaoxiang.java1.Person.toString()
		public int com.liaoxiang.java1.Person.compareTo(java.lang.Object)
		public java.lang.String com.liaoxiang.java1.Person.getName()
		public int com.liaoxiang.java1.Person.getId()
		public void com.liaoxiang.java1.Person.setName(java.lang.String)
		public void com.liaoxiang.java1.Person.show()
		public static void com.liaoxiang.java1.Person.info()
		private java.lang.Integer com.liaoxiang.java1.Person.display(java.lang.String,java.lang.Integer) throws java.lang.Exception
		public void com.liaoxiang.java1.Person.setAge(java.lang.Integer)
		public void com.liaoxiang.java1.Person.setAge(int)
		public void com.liaoxiang.java1.Person.setId(int)
		public int com.liaoxiang.java1.Person.getAge()
    }
    // 获取注解 权限修饰符 返回值类型 方法名 形参列表 异常
    @Test
    public void test2(){
        Class<Person> personClass = Person.class;
        Method[] declaredMethods = personClass.getDeclaredMethods();

        for (Method declaredMethod : declaredMethods) {
            //1、获取注解
            Annotation[] annotations = declaredMethod.getAnnotations();
            for (Annotation annotation : annotations) {
                System.out.println("注解："+annotation);
            }
            //2、获取权限修饰符：getModifiers()
            String string = Modifier.toString(declaredMethod.getModifiers());
            System.out.print("权限修饰符："+string+" ");
            //3、返回值类型：getReturnType()
            Class<?> returnType = declaredMethod.getReturnType();
            System.out.print("返回值类型："+returnType.getName()+" ");
            //4、方法名
            System.out.print("方法名："+declaredMethod.getName()+" ");
            //5、形参列表
            System.out.print("(");
            Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
            for (int i = 0; i < parameterTypes.length; i++) {
                System.out.print("形参列表："+parameterTypes[i].getName() + "args-"+i+" ");
            }
            System.out.print(")");
            //6、异常
            Class<?>[] exceptionTypes = declaredMethod.getExceptionTypes();
            if (exceptionTypes.length != 0){
                System.out.print(" throws ");
            }
            for (int i = 0; i < exceptionTypes.length; i++) {
                System.out.print("异常："+exceptionTypes[i].getName()+" ");
            }
            System.out.println();
        }
	权限修饰符：public 返回值类型：java.lang.String 方法名：toString ()
	权限修饰符：public 返回值类型：int 方法名：compareTo (形参列表：java.lang.Objectargs-0 )
	权限修饰符：public 返回值类型：java.lang.String 方法名：getName ()
	权限修饰符：public 返回值类型：int 方法名：getId ()
	权限修饰符：public 返回值类型：void 方法名：setName (形参列表：java.lang.Stringargs-0 )
	权限修饰符：private 返回值类型：java.lang.Integer 方法名：display (形参列表：java.lang.Stringargs-0 形参列表：java.lang.Integerargs-1 ) throws 异常：java.lang.Exception 
	注解：@com.liaoxiang.java1.MyAnnotation(value=jack)
	权限修饰符：public 返回值类型：void 方法名：show ()
	权限修饰符：public static 返回值类型：void 方法名：info ()
	权限修饰符：public 返回值类型：int 方法名：getAge ()
	权限修饰符：public 返回值类型：void 方法名：setAge (形参列表：java.lang.Integerargs-0 )
	权限修饰符：public 返回值类型：void 方法名：setAge (形参列表：intargs-0 )
	权限修饰符：public 返回值类型：void 方法名：setId (形参列表：intargs-0 )
    }
    /**
     * 调用运行时类指定的方法,Object invoke(Object obj, Object ... obj)
     *      invoke 方法的返回值就是获取的具体方法的返回值
     */
    @Test
    public void test3() throws Exception{
        Class<Person> personClass = Person.class;
        // 调用普通方法，无返回值
        Method method1 = personClass.getMethod("show");
        Person p = personClass.newInstance();
        method1.invoke(p);
        // 调用普通方法，有返回值
        Method method2 = personClass.getMethod("toString");
        Object result = method2.invoke(p);
        System.out.println(result);
        // 调用静态方法
        Method method3 = personClass.getMethod("info");
        method3.invoke(Person.class);
        // 获取运行时类的所有声明的方法
        Method method4 = personClass.getDeclaredMethod("display", String.class, Integer.class);
        method4.setAccessible(true);
        Object value = method4.invoke(p, "中国", 10);
        System.out.println(value);
    }
    调用了Person的空参构造器
	我是一个人！
	Person{name='null', age=null, id=0}
	静态方法：我是一个中国人
	我的国籍是：中国
	10
}