你需要注意的Java小细节（一）

1. 调用静态常量不会引起初始化（调用初始化代码块）。但是要调用类的静态方法当然会初始化类了

class Test{
    static{
                  System.out.println("初始化");
     }
        public  final static  String  str="ddd";
}
public class Main {
public static void main(String[] args) {
System.out.println(Test.str);
}
}

输出ddd。

2.关于静态代理与动态代理

public class ProxyTest {

    public static void main(String[] args){

            Class clazz = Proxy.getProxyClass(Person.class.getClassLoader(), Person.class);
           System.out.println(clazz);
           System.out.println(Person.class);
    }

}
public interface Person {
    public   void  sayHello();
}

输出：

class com.sun.proxy.$Proxy0
interface main.Person

为什么需要一个classloader,就是因为class是动态生成的。这个class就是代理对象。(也就是被扩展了的Person对象。Person是一个接口）
Java中的代理与OC中的委托基本类似。但是区别不同的是，JAVA中的代理对象包裹着被代理的对象（得到的是被扩展的Person对象）
。而OC中代理对象是作为被代理对象的一个属性。（个人觉得，OC中的代理更能体现面向对象编程，尤其是对多态的理解。）

也就是说，java中的代理最终获得的是代理对象（虽然是Person接口，但是不是我们自己处理逻辑的的那个实现对象），而在OC中获得的是原对象。

Class proxyClass= Proxy.getProxyClass(Person.class.getClassLoader(), Person.class);
         InvocationHandler handler = new MyInvocationHandler();
         Person f = (Person) proxyClass.getConstructor(InvocationHandler.class).newInstance(handler);
         System.out.println(f);

proxyClass的getConstructor得到的是代理类的构造器对象，而不是person的构造器对象。

使用代理可以根据接口动态的生成对象，所谓的动态代理就是根据接口动态生成代理对象而已。

public class ProxyTest {

    public static void main(String[] args) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException{

            Class proxyClass= Proxy.getProxyClass(Person.class.getClassLoader(), Person.class);
         InvocationHandler handler = new MyInvocationHandler();
       Person  person= (Person) proxyClass.getConstructor(InvocationHandler.class).newInstance(handler);
      person.sayHello();  
    }
}
public class MyInvocationHandler  implements  InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      System.out.println("我被调用了！");
        return null;
    }
}

调用这个动态生成对象（扩展了的Person对象)的任何方法都将调用invoke方法。
动态代理：

    public static void main(String[] args) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException{
             Class proxyClass= Proxy.getProxyClass(Person.class.getClassLoader(), Person.class);
             MyInvocationHandler handler = new MyInvocationHandler();
             //person是一个接口。我们自己的处理逻辑还需要实现：
             handler.setTarget(new PersonImpl());
//person是加入了InvocationHandler的person:
             Person  person= (Person )proxyClass.getConstructor(InvocationHandler.class).newInstance(handler);
             person.sayHello("Jetty"); 
    }
public class MyInvocationHandler implements InvocationHandler {
    private Person person;
    public void setTarget(Person target) {
        this.person = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        new Before().before();
         method.invoke(person, args[0]);//自己的逻辑调用。成员变量person
        return null;
    }
}
public class Before {
    public    void    before(){
        System.out.println("before");
    }
}

可以看出，java中的动态代理体现了java中最重要的一点：面向接口编程。这样生成的代理类也是一个Person对象。