Java基础知识（20）- Java 反射机制 (二) | 执行方法（访问方法）、访问数组、操作泛型(Generics)

1. 通过反射执行方法（访问方法）

    要动态获取一个对象方法的信息，首先需要通过下列方法之一创建一个 Method 类型的对象或者数组。

        getMethods()
        getMethods(String name,Class<?> …parameterTypes)
        getDeclaredMethods()
        getDeclaredMethods(String name,Class<?>...parameterTypes)

    如果是访问指定的构造方法，需要根据该方法的入口参数的类型来访问。例如，访问一个名称为 max，入口参数类型依次为 int 和 String 类型的方法。

    下面的两种方式均可以实现：

        objectClass.getDeclaredConstructor("max",int.class,String.class);
        objectClass.getDeclaredConstructor("max",new Class[]{int.class,String.class});

    Method 类的常用方法如表所示。

 

静态方法名称	说明
getName()	获取该方法的名称
getParameterType()	按照声明顺序以 Class 数组的形式返回该方法各个参数的类型
getReturnType()	以 Class 对象的形式获得该方法的返回值类型
getExceptionTypes()	以 Class 数组的形式获得该方法可能抛出的异常类型
invoke(Object obj,Object...args)	利用 args 参数执行指定对象 obj 中的该方法，返回值为 Object 类型
isVarArgs()	查看该方法是否允许带有可变数量的参数，如果允许返回 true，否则返回 false
getModifiers()	获得可以解析出该方法所采用修饰符的整数

 
    实例：

        import java.lang.reflect.Method;

        public class App {
            public static void main( String[] args ) {

                // 通过反射执行方法（访问方法）
                BookMethod bookMethod = new BookMethod();
                Class bookMethodClass = bookMethod.getClass();

                Method[] declaredMethods = bookMethodClass.getDeclaredMethods();

                for (int i = 0; i < declaredMethods.length; i++) {

                    Method method = declaredMethods[i];

                    System.out.println("方法名称 -> " + method.getName());

                    System.out.print("参数类型 -> ( ");
                    Class[] parameterTypes = method.getParameterTypes();
                    for (int j = 0; j < parameterTypes.length; j++) {
                        System.out.print(parameterTypes[j]);
                        if (j < parameterTypes.length-1)
                            System.out.print(", ");
                    }
                    System.out.print(" )\n");

                    System.out.println("是否带可变数量参数 -> " + method.isVarArgs());
                    System.out.println("返回值类型 -> " + method.getReturnType());

                    System.out.print("可能抛出的异常类型 -> ( ");

                    Class[]  methodExceptions = method.getExceptionTypes();
                    for (int j = 0; j < methodExceptions.length; j++) {
                        System.out.print(methodExceptions[j]);
                        if (j < methodExceptions.length-1)
                            System.out.print(", ");
                    }
                    System.out.print(" )\n");

                    // 方法的访问权限为 private，会拋出异常；
                    // 或调用 setAccessible(true) 设置允许访问 private 成员
                    //method.setAccessible(true);

                    try {
                        if (method.getName().equals("publicMethod")) {
                            System.out.println("publicMethod(1) = " + method.invoke(bookMethod, 1));
                        } else if (method.getName().equals("protectedMethod")) {
                            System.out.println("protectedMethod(\"3\", 8) = " + method.invoke(bookMethod, "3", 8));
                        } else if (method.getName().equals("privateMethod")) {
                            Object[] parameters = new Object[] { new String[] { "T", "E", "S", "T" } };
                            System.out.println("privateMethod(...) = " + method.invoke(bookMethod, parameters));
                        } else {
                            method.invoke(bookMethod);
                        }
                    } catch (Exception e) {
                        //e.printStackTrace();
                        System.out.println("调用该方法失败：error -> " + e.getMessage());
                    }

                    System.out.println("----------------------------------------------");
                }
            }
        }

        class BookMethod {

            // 默认访问权限方法
            void defaultMethod() {
                System.out.println("执行 defaultMethod() 方法");
            }

            // 默认访问权限 static 方法
            static void defaultStaticMethod() {
                System.out.println("执行 defaultStaticMethod() 方法");
            }

            // public 方法
            public int publicMethod(int i) {
                System.out.println("执行 publicMethod() 方法");
                return 100 + i;
            }

            // protected 方法
            protected int protectedMethod(String s, int i) throws NumberFormatException {
                System.out.println("执行 protectedMethod() 方法");
                return Integer.valueOf(s) + i;
            }

            // private 方法
            private String privateMethod(String... args) {
                System.out.println("执行 privateMethod() 方法");
                StringBuffer sb = new StringBuffer();
                for (int i = 0; i < args.length; i++) {
                    sb.append(args[i]);
                }
                return sb.toString();
            }

        }

    输出：

        方法名称 -> privateMethod
        参数类型 -> ( class [Ljava.lang.String; )
        是否带可变数量参数 -> true
        返回值类型 -> class java.lang.String
        可能抛出的异常类型 -> (  )
        调用该方法失败：error -> Class com.example.ReflectionApp can not access a member of class com.example.BookMethod with modifiers "private transient"
        ----------------------------------------------
        方法名称 -> protectedMethod
        参数类型 -> ( class java.lang.String, int )
        是否带可变数量参数 -> false
        返回值类型 -> int
        可能抛出的异常类型 -> ( class java.lang.NumberFormatException )
        执行 protectedMethod() 方法
        protectedMethod("3", 8) = 11
        ----------------------------------------------
        方法名称 -> publicMethod
        参数类型 -> ( int )
        是否带可变数量参数 -> false
        返回值类型 -> int
        可能抛出的异常类型 -> (  )
        执行 publicMethod() 方法
        publicMethod(1) = 101
        ----------------------------------------------
        方法名称 -> defaultMethod
        参数类型 -> (  )
        是否带可变数量参数 -> false
        返回值类型 -> void
        可能抛出的异常类型 -> (  )
        执行 defaultMethod() 方法
        ----------------------------------------------
        方法名称 -> defaultStaticMethod
        参数类型 -> (  )
        是否带可变数量参数 -> false
        返回值类型 -> void
        可能抛出的异常类型 -> (  )
        执行 defaultStaticMethod() 方法

2. 通过反射访问数组

    java.lang.reflect.Array 类提供静态方法来动态创建和访问Java数组。

    实例：

       import java.lang.reflect.Field;

        public class App {
            public static void main( String[] args ) {
            
            // 通过反射访问数组
            Class<?> classType = null;
            Object newArray = null;
            try {
                classType = Class.forName("java.lang.String");
                newArray = Array.newInstance(classType, 3);
            } catch (Exception e) {
                //e.printStackTrace();
                System.out.println("Create array instance failed:  " + e.getMessage());
                return;
            }
            Array.set(newArray, 0, "Country");
            Array.set(newArray, 1, "Province");
            Array.set(newArray, 2, "City");

            printArray(newArray);
            printArray("It is string");
            
        }

        private static void printArray(Object obj) {
            Class cls = obj.getClass();
            // 判断是否是数组
            if (cls.isArray()) {
                int arrLen = Array.getLength(obj);
                for (int i = 0; i < arrLen; i++){
                    System.out.println("Array(" + cls.getComponentType().getName() + ") : " + Array.get(obj, i));
                }
            }else {
                // 不是数组，直接输出
                System.out.println(obj);
            }
        }
    }

    输出：

        Array(java.lang.String) : Country
        Array(java.lang.String) : Province
        Array(java.lang.String) : City
        It is string

3. 通过反射操作泛型(Generics)

    Java 5 开始增加了 ParameterizedType, GenericArrayType, TypeVariable 和 WildcardType 几种类型，在 java.lang.reflect 包。
　　
        ParameterizedType: 表示一种参数化的类型，比如Collection< String >
        GenericArrayType: 表示一种元素类型是参数化类型或者类型变量的数组类型
        TypeVariable: 是各种类型变量的公共父接口
        WildcardType: 代表一种通配符类型表达式，比如？、？ extends Number、？ super Integer。（wildcard是一个单词：就是”通配符“）

    实例：

        import java.lang.reflect.Method;
        import java.lang.reflect.ParameterizedType;
        import java.lang.reflect.Type;
        import java.util.List;
        import java.util.Map;

        public class App {  
            public static void main(String[] args) {

                try {
                    // 获得指定方法参数泛型信息
                    Method method = Demo.class.getMethod("testMethod01", Map.class, List.class);
                    Type[] paramTypes = method.getGenericParameterTypes();

                    System.out.println("testMethod01() 的参数类型");
                    for (Type t : paramTypes) {
                        if(t instanceof ParameterizedType){
                            Type[] genericTypes = ((ParameterizedType) t).getActualTypeArguments();
                            for (Type genericType : genericTypes) {
                                System.out.println("参数类型 -> " + genericType);
                            }
                        }
                    }

                    System.out.println("testMethod02() 的返回值类型");
                    Method method2 = Demo.class.getMethod("testMethod02", null);
                    Type returnType = method2.getGenericReturnType();
                    if(returnType instanceof ParameterizedType){
                        Type[] genericTypes = ((ParameterizedType) returnType).getActualTypeArguments();

                        for (Type genericType : genericTypes) {
                            System.out.println("返回值类型 -> "+genericType);
                        }
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

        class Demo {

            public void testMethod01(Map<String, Demo> map, List<Demo> list){
                System.out.println("Demo.testMethod01()");
            }

            public Map<Integer,Demo> testMethod02(){
                System.out.println("Demo.testMethod02()");
                return null;
            }
        }

 

    输出：

        testMethod01() 的参数类型
        参数类型 -> class java.lang.String
        参数类型 -> class com.example.Demo
        参数类型 -> class com.example.Demo
        testMethod02() 的返回值类型
        返回值类型 -> class java.lang.Integer
        返回值类型 -> class com.example.Demo