特殊的静态代理模式，允许对象组合实现与继承相同的代码重用。
    代理模式注重过程
    委派模式注重结果

    框架
    JDK加载类时使用双亲委派模型
    一个类加载器在加载类时，先把这个请求委派给自己的父类加载器去执行。如果父类加载器还存在父类加载器，则继续向上委派，直到顶层的启动类加载器；如果父类加载器能够完成类加载，则成功返回；如果父类加载器无法完成加载，则子加载器尝试自己去加载

    1. abstract class ClassLoader{
    2.     protect ClassLoader parent;
    4.       protected Class<?> loadClass(String name, boolean resolve)
    5.         throws ClassNotFoundException{
    6.         synchronized (getClassLoadingLock(name)) {
    7.             // First, check if the class has already been loaded
    8.             Class<?> c = findLoadedClass(name);
    9.             if (c == null) {
    10.                 long t0 = System.nanoTime();
    11.                 try {
    12.                     if (parent != null) {
    13.                         c = parent.loadClass(name, false);
    14.                     } else {
    15.                         c = findBootstrapClassOrNull(name);
    16.                     }
    17.                 } catch (ClassNotFoundException e) {
    18.                     // ClassNotFoundException thrown if class not found
    19.                     // from the non-null parent class loader
    20.                 }
    22.                 if (c == null) {
    23.                     // If still not found, then invoke findClass in order
    24.                     // to find the class.
    25.                     long t1 = System.nanoTime();
    26.                     c = findClass(name);
    28.                     // this is the defining class loader; record the stats
    29.                     sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
    30.                     sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
    31.                     sun.misc.PerfCounter.getFindClasses().increment();
    32.                 }
    33.             }
    34.             if (resolve) {
    35.                 resolveClass(c);
    36.             }
    37.             return c;
    38.         }
    39.     }
    40. }