1.    class Test2 {
   
2.               public static void main(String[] args) {
   
3.                 Collection proxyArrayList = (Collection)Proxy.newProxyInstance(
   
4. 
   
5.                                 Collection.class.getClassLoader(),
   
6. 
   
7.                                 new Class[]{Collection.class},
   
8.                                                
   
9.                                 new InvocationHandler() {
   
10.                                         ArrayList target = new ArrayList();
    
11.                                                         public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
    
12.                                         System.out.println(method);
    
13.                                                        System.out.println(target.getClass().getMethod("add", Object.class));
    
14.                                                         Object obj = method.invoke(target, args);
    
15.                                                        return obj;  
    
16.                                                 }
    
17.                                         });
    
18.                         proxyArrayList.add("abc");
    
19. 
    
20.                 }
    

复制代码

打印结果：
public abstract boolean java.util.Collection.add(java.lang.Object)
public boolean java.util.ArrayList.add(java.lang.Object)


上面是张孝祥老师讲解动态代理类时的一段代码，我很奇怪传进invoke的那个method是谁的方法，于是改了下代码验证，
method的字节码对象和target的add方法的字节码文件不一样啊，也就是method的add方法不是target的add方法。
method的add方法是public abstract boolean java.util.Collection.add中的方法他的方法是空的啊怎么能调用invoke方法，
更奇怪的是一个空的方法怎么向集合中添加元素呢。

import java.lang.reflect.*;

public class TestAgent {
    public static void main(String[] args) {
            Agent agent=new Agent();
            BAgentFace bAgentFace=null;
            agent.setObj(new BAgent());
            bAgentFace=(BAgentFace)Proxy.newProxyInstance(BAgentFace.class.getClassLoader(),new Class[]{BAgentFace.class},agent);
            bAgentFace.add();
    }
}
class Agent implements InvocationHandler
{
        private Object obj;
       
        public void setObj(Object obj) {
                this.obj = obj;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args)
                        throws Throwable {
               
                return method.invoke(obj,args);
        }
       
}
class BAgent implements BAgentFace
{
        public void add()
        {
                System.out.println("ni hao");
        }
}
interface BAgentFace
{
        public void add();
}

这里利用了java中一个重要的特征，多态，简单点说，父类引用指向了子类对象，其实就是
Collectioin target =new ArrayList();
tartget.add()；
多态的出现是为了增强程序的扩展性，如果你把target换成别的集合还可以使用这个程序，如果你写成ArrayList它就是一个死程序，没有扩展性。