代理模式和装饰者模式的异同点比较

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();
    }
}

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

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


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

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

 

 两者的定义
装饰器模式：能动态的新增或组合对象的行为。
代理模式：为其他对象提供一种代理以控制对这个对象的访问.
装饰模式是“新增行为”，而代理模式是“控制访问”。关键就是我们如何判断是“新增行为”还是“控制访问”。

原句：I think we’re all aware that the decorator pattern is used to add behavior to existing code. This does not stop at one kind of behavior but any number of different things that we want to do.
意译：装饰类只能新增行为，不能跳过其他的任何一个行为。