使用反射来创建对象、调用方法

港控/mmm° 2021-09-25 11:56 397阅读 0赞

### 使用反射来创建对象、调用方法 ###

*  反射创建对象
 *  反射调用方法
 *  反射调用私有方法
 *  反射调用可变参私有方法
 *  反射调用的方法自身可以抛出异常的情形

假设已有下面的类：

import java.lang.reflect.InvocationTargetException;
    
    public class Test { 
        public Test() { 
        }
    
        public Test(A paraA, B paraB) { 
            System.out.println("构造器 Test(A paraA, B paraB) 被调用。");
            System.out.println(" > paraA：" + paraA);
            System.out.println(" > paraB：" + paraB);
            System.out.println("");
        }
    
        public void fun(A paraA, B paraB) { 
            System.out.println("函数 fun(A paraA, B paraB) 被调用。");
            System.out.println(" > paraA：" + paraA);
            System.out.println(" > paraB：" + paraB);
            System.out.println("");
        }
    }
    
        private void privateFun(A paraA, B paraB) { 
            System.out.println("函数 privateFun(A paraA, B paraB) 被调用。");
            System.out.println(" > paraA：" + paraA);
            System.out.println(" > paraB：" + paraB);
            System.out.println("");
        }
    
        public static void main(String[] args) { 
            /** * 此处代码将于下面分节补充 */
        }
    
    
    class A { 
        private String info;
    
        public A() { 
        }
    
        public A(String str) { 
            this.info = str;
        }
    
        @Override
        public String toString() { 
            return this.info;
        }
    }
    
    class B { 
        private String info;
    
        public B() { 
        }
    
        public B(String str) { 
            this.info = str;
        }
    
        @Override
        public String toString() { 
            return this.info;
        }
    }

# 反射创建对象 #

创建上述 Test 对象的办法是：

public static void main(String[] args)
                throws NoSuchMethodException, IllegalAccessException,
                InvocationTargetException, InstantiationException { 
            /** * 构造器 Test(A paraA, B paraB) 被调用。 * > paraA：aaaaa * > paraB：bbbbb */
            A a = new A("aaaaa");
            B b = new B("bbbbb");
            Test test = Test.class
                    .getConstructor(A.class, B.class)
                    .newInstance(a, b);
    
        }

# 反射调用方法 #

调用上述 Test 对象的方法的办法是：

public static void main(String[] args)
                throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { 
            /** * 函数 fun(A paraA, B paraB) 被调用。 * > paraA：aaaaa * > paraB：bbbbb */
            Test test = new Test();
            A a = new A("aaaaa");
            B b = new B("bbbbb");
            test.getClass()
                    .getMethod("fun", A.class, B.class)
                    .invoke(test, a, b);
    
        }

# 反射调用私有方法 #

调用上述 Test 对象的**私有**方法的办法是：

public static void main(String[] args)
                throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { 
            /** * 函数 privateFun(A paraA, B paraB) 被调用。 * > paraA：aaaaa * > paraB：bbbbb */
            Test test = new Test();
            A a = new A("aaaaa");
            B b = new B("bbbbb");
            var methodToBeTested = test.getClass()
                    .getDeclaredMethod("privateFun", A.class, B.class);
            methodToBeTested.setAccessible(true); // 如果此处的类本来就有权限调用用反射调用的方法，则此行代码可以省略
            methodToBeTested.invoke(test, a, b);
        }

# 反射调用可变参私有方法 #

调用上述 Test 对象的可变参私有方法的办法是：

public static void main(String[] args)
                throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { 
            System.out.println("");
    
            /** * 函数 varParaFun(A... paraAs) 被调用。 * > para：a11111 * > para：a22222 */
            Test test = new Test();
            A aFirst = new A("a11111");
            A bSecond = new A("a22222");
            A[] paraAs = new A[]{ aFirst, bSecond};
            // 将可变参数视为数组参数
            var methodToBeTested = test.getClass()
                    .getDeclaredMethod("varParaFun", A[].class);
            methodToBeTested.setAccessible(true); // 如果此处的类本来就有权限调用用反射调用的方法，则此行代码可以省略
            // 还必须将可变参数组再封装到一个数组中
            methodToBeTested.invoke(test, new Object[]{ paraAs});
        }

# 反射调用的方法自身可以抛出异常的情形 #

如果反射调用的方法本身可以抛出异常，则当其抛出异常时，此异常会被反射“吞掉”，封装成 InvocationTargetException 异常重新抛出。可以使用该封装异常的方法 getTargetException 或 getCause 来获取被吞掉的异常。例如，

try { 
            /** * 此处为某反射调用代码 */
        } catch (InvocationTargetException exception) { 
            Throwable realException = exception.getTargetException();
            if (realException instanceof MyXXXException) { 
                throw (MyXXXException) realException;
            } else { 
                // TODO：可以选择再抛出 InvocationTargetException 异常，也可以抛出自己想抛出的异常。或者做其它事情。
            }
        }