胡说八道：代理模式和装饰者模式的异同点比较

    1：代理模式：
    为其它对象提供一种代理以控制对目标对象的访问。即第三方对象通过访问代理对象而达到访问目标对象之目的，与此同时，代理对象在访问目标对象前后加入特定的逻辑以实现功能的扩展。
     以静态代理为例：

package  static_proxy;

public   interface  Movable {
     public   void  move();

}

package  static_proxy;

import  java.util.Random;

public   class  Tank  implements  Movable {
    @Override
     public   void  move() {
        System.out.println( "  Tank is moving   " );
         try  {
            Thread.sleep( new  Random().nextInt( 1000 ));
        }  catch  (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

package  static_proxy;

public   class  TankLogProxy  implements  Movable {
     private  Movable obj;
     public  TankLogProxy(Movable obj) {
         super ();
         this .obj  =  obj;
    }
    @Override
     public   void  move() {
        System.out.println( " the log is begin   " );
        obj.move();
        System.out.println( " the log is end   " );
    }
}

package  static_proxy;

public   class  TankTimeProxy  implements  Movable {    
     private  Movable obj;
     public  TankTimeProxy(Movable obj) {
         super ();
         this .obj  =  obj;
    }
    @Override
     public   void  move() {
         long  begintime  =  System.currentTimeMillis();
        System.out.println( "  Tank is begining to move ! " );
        obj.move();
         long  endtime  =  System.currentTimeMillis();
        System.out.println( "  Tank is stop ! " );
        System.out.println( " move time :  " + (endtime - begintime));
    }
}

package  static_proxy;
public   class  Client {
     /**
     *  @param  args
      */
     public   static   void  main(String[] args) {
        Movable tankTime  =   new  TankTimeProxy( new  Tank());
        Movable tankLog  =   new  TankLogProxy(tankTime);
        tankLog.move();
    }
}

代理模式：目标对象和代理对象实现同一接口；代理对象访问目标对象时在其前后加入一定的逻辑实现功能扩展；可多次代理。

2.装饰者模式：
    

动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更加灵活。

package  decorator;

public   abstract   class  car_parent {
     //  汽车抽象父类
     private  String make_address;
     private   int  speed;

     public  String getMake_address() {
         return  make_address;
    }

     public   void  setMake_address(String make_address) {
         this .make_address  =  make_address;
    }

     public   int  getSpeed() {
         return  speed;
    }

     public   void  setSpeed( int  speed) {
         this .speed  =  speed;
    }

     public   abstract   void  print_face();

}

package  decorator;

public   abstract   class  decorator_parent  extends  car_parent {
     //  装饰者父类
     protected  car_parent car_parent_ref;

     public  decorator_parent(car_parent carParentRef) {
         super ();
        car_parent_ref  =  carParentRef;
    }
    @Override
     public   void  print_face() {
        car_parent_ref.print_face();
    }

}

package  decorator;
public   class  decorator_audi_red  extends  decorator_parent {
     public  decorator_audi_red(car_parent carParentRef) {
         super (carParentRef);
    }
    @Override
     public   void  print_face() {
         super .print_face();
        System.out.println( " 给　奥迪　喷涂鸦　-　颜色为　红色火焰 " );
    }
}

package  decorator;
public   class  decorator_audi_purple  extends  decorator_parent {

     public  decorator_audi_purple(car_parent carParentRef) {
         super (carParentRef);
    }
    @Override
     public   void  print_face() {
         super .print_face();
        System.out.println( " 给　奥迪　喷涂鸦　-　颜色为　紫色霞光 " );
    }
}

package  decorator;

public   class  main_run {
     public   static   void  main(String[] args) {

        car_parent audi_sub_ref  =   new  audi_sub();
        audi_sub_ref.setMake_address( " 北京市朝阳区 " );
        audi_sub_ref.setSpeed( 200 );
        
        decorator_audi_red decorator_audi_red_ref  =   new  decorator_audi_red(audi_sub_ref);

        decorator_audi_purple decorator_audi_purple_ref  =   new  decorator_audi_purple(decorator_audi_red_ref);
        decorator_audi_purple_ref.print_face();
    }
}

装饰者模式：装饰者和被装饰者应继承或实现同一父类或接口，以表示它们为同一类对象（非必须）；装饰者对象对被装饰者对象增加一定的职责；可多次装饰。

可以发现：代理模式和装饰者模式上在语法形式上几乎完全一样，那么它们的区别在哪里呢？
装饰者模式：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更加灵活
代理模式： 为其它对象提供一种代理以控制对这个对象的访问。


其实，它们的着重点一个在于“增加”职责，另一个在于“控制”访问。这是它们最本质的区别。

由此可以看到：学习设计模式重点在于“语义”上把握，而不是追求它的“形式。