Java设计模式（9）——结构型模式之装饰模式（Decorator）

一、概述

　　动态地给一个对象添加一些额外的职责。就增加功能来说， Decorator模式相比生成子类更为灵活。该模式以对客 户端透明的方式扩展对象的功能。

　　UML简图

　　

　　角色

　　

　　在持有Component的引用后，由于其自身也是Component的子类，那么，相当于ConcreteDecorator包裹了Component，不但有Component的特性，同时自身也可以有别的特性，也就是所谓的装饰。

 二、实践

　　根据上面的角色，创建相应的角色

　　抽象构件

/**
 * 抽象组件
 *
 * @author Administrator
 * 日期: 2017/10/28
 **/
public interface Component {
    void operation1();
}

　　具体构件

 

/**
 * 具体组件
 *
 * @author Administrator
 * 日期： 2017/10/29
 **/
public class ConcreteComponent implements Component{
    @Override
    public void operation1() {
        // 具体操作
        System.out.println("明星唱歌！");
    }
}

 

　　装饰者

 

/**
 * 装饰者
 *
 * @author Administrator
 * 日期： 2017/10/29
 **/
public class Decorator implements Component{
    private Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    public Decorator() {
    }

    @Override
    public void operation1() {
        // 调用component的操作方法
        component.operation1();
    }
}

　　具体装饰者（可以有不同的装饰者）

/**
 * 具体装饰者
 *
 * @author Administrator
 * 日期： 2017/10/29
 **/
public class ConcreteDecorator extends Decorator {
    public ConcreteDecorator(Component c) {
        super(c);
    }
    @Override
    public void operation1() {
        System.out.println("先交门票钱！");
        super.operation1();
    }
}

　　装饰者2号

/**
 * 具体装饰者2号
 *
 * @author Administrator
 *         日期： 2017/10/29
 **/
public class ConcreteDecorator2 extends Decorator{
    public ConcreteDecorator2(Component c) {
        super(c);
    }
    @Override
    public void operation1() {
        System.out.println("先点击购票！");
        super.operation1();
    }
}

　　一个典型的装饰者模式的出场方式如下：（比如我们的缓冲流）

　　

　　客户端实际使用示例

/**
 * 客户端
 * @author  Administrator
 * 日期： 2017/10/26
 **/
public class Client {
    public static void main(String[] args) {
        Component c = new ConcreteComponent();
        Decorator d = new ConcreteDecorator(new ConcreteDecorator2(c));
        d.operation1();
    }
}

　　// 这样使用是基于家谱的正确性（所以上图的参数可以正确传递），如下图所示：

　　

　　结果如下：

　　

　过程分析：

　　关键是每个具体装饰类都有一个super的构造的调用，首先看d.opreation1()方法，调用了装饰者1的方法，里面先执行了自己的逻辑，再执行c.opreation1()

但此时这个c这个Component是构造器里传入的装饰者2（家谱的正确性）,关键就是实现了同一接口（看家谱图），所以最后出现了1和2叠加的逻辑。

　　具体的装饰过程如果还不是很理解，可以 尝试着在IDE里看看代码的调用

三、改进与思考

　　适用场景

　　

　　实际案例（Java IO）

　　

 

 　　模式简化

　　 1. 如果没有Component接口，只有一个ConcreteComponent，那么Decorator是此ConcreteComponent（扮演双重角色）的一个子类

　　  2.如果只有一个ConcreteDecoretor类（甚至只有两个也可以这么做），那么可以没有Decorator接口，可以把Decoretor和ConcreteDecorator类合并为一个类

　　一句口诀

　　是你还有你，一切拜托你。（意会）

　　透明性要求

　　根据透明性要求，我们也可以利用多态很容易做到这点：（如果子类有新增的方法，则不能采用此方式）,

 public static void main(String[] args) {
        Component c = new ConcreteComponent();
        Component d = new ConcreteDecorator(new ConcreteDecorator2(c));
        d.operation1();
    }

 　　装饰者和被装饰者拥有不完全一样的接口（例如装饰者有新增方法），则称为不完全透明的装饰者模式！