@Test
    public void test1() throws InstantiationException, IllegalAccessException {
        Class<Person> clazz = Person.class;
        /*
            newInstance():调用此方法，创建对应的运行时类的对象，内部调用了运行时类的空参构造器
            要想此方法正常的创建运行时类的对象，要求：
            1.运行时类必须提供空参构造器
            2.空参的构造器反问权限得够
            在javabean中要求提供一个public的空参构造器，原因：
            1.便于通过反射，创造运行时类的对象
            2.便于子类继承此运行类时，默认调用super()时，保证父类有此构造器
         */
        Person obj = (Person) clazz.newInstance();
        System.out.println(obj);
    }

@Test
    public void testMethod() throws Exception {
        Class clazz = Person.class;
        //创建运行时类的对象
        Person p = (Person) clazz.newInstance();
        /*
        //1.获取指定的某个方法
        getDeclaredMethod():参数1：指明获取方法的名称   参数2：指明获取方法的形参列表
         */
        Method show = clazz.getDeclaredMethod("show", String.class);
        //2.保证当前方法是可访问的
        show.setAccessible(true);
        /*
        2.invoke():参数1：方法的调用者     参数2：给方法形参赋值的实参
        invoke()的返回值即为对应类在调用的方法的返回值
         */
        Object returnValue = show.invoke(p, "CHN");//String nation = p.show("CHN")
        System.out.println(returnValue);//CHN
        System.out.println("****************如何调用静态方法*****************");
        //private static void showDesc()
        Method showDesc = clazz.getDeclaredMethod("showDesc");
        showDesc.setAccessible(true);
        //如果调用的运行时类中的方法没有返回值，则此invoke()返回null
        Object returnVal = showDesc.invoke(Person.class);
        System.out.println(returnVal);//null
    }

interface Human{
    String getBelief();
    void eat(String food);
}
//被代理类
class SuperMan implements Human{
    @Override
    public String getBelief() {
        return "I believe I can fly!";
    }
    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃" + food);
    }
}
class ProxyFactory{
    //调用此方法返回一个代理类的对象
    public static Object getProxyInstance(Object obj){//obj:被代理类的对象
        MyInvocationHandler hander = new MyInvocationHandler();
        hander.bind(obj);
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),hander);
    }
}
class MyInvocationHandler implements InvocationHandler{
    private Object obj;//需要使用被代理类的对象进行赋值
    public void bind(Object obj){
        this.obj = obj;
    }
    //当我们通过代理类的对象，调用方法a时就会自动调用如下的方法：invoke()
    //将被代理类要执行的方法a的功能就声明在invoke()方法中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
        //obj：被代理类的对象
        Object returnValue = method.invoke(obj, args);
        //上述方法的返回值就作为当前类中的invoke()的返回值
        return returnValue;
    }
}
public class ProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        //proxyInstance：代理类的对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        //当通过代理类对象调用方法时，会自动的调用被代理了中同名的方法
        String belief = proxyInstance.getBelief();
        System.out.println(belief);
        proxyInstance.eat("四川麻辣烫");
    }
}