设计模式学习---第二节：装饰模式

 

 

1、意图

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

2、适用环境

（1）在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。

（2）处理那些可以撤消的职责。

（3）当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的 子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。

 

3、参与者

    1.Component（被装饰对象的基类）

      定义一个对象接口，可以给这些对象动态地添加职责。

    2.ConcreteComponent（具体被装饰对象）

      定义一个对象，可以给这个对象添加一些职责。

    3.Decorator（装饰者抽象类）

      维持一个指向Component实例的引用，并定义一个与Component接口一致的接口。

    4.ConcreteDecorator（具体装饰者）

      具体的装饰对象，给内部持有的具体被装饰对象，增加具体的职责。

4、类图

 

 

5、涉及角色

（1）抽象组件（Component）:定义一个接口或者抽象类，来规范准备附加功能的类,定义最核心的对象,这个类是装饰者的基类

（2）具体组件（ConcreteComponent）：将要被附加功能的类，实现抽象组件角色接口

（3）抽象装饰者（Decorator）：一般是抽象类,持有对具体组件角色的引用并定义与抽象组件角色一致的接口（实现Component,它里面必然有一个指向Component的引用）

（4）具体装饰者（ConcreteDecorator）：实现抽象装饰者角色，负责对具体组件添加额外功能。

6、代码 

Component 

public interface Person {

    void eat();
}

ConcreteComponent 

public class Man implements Person {

    public void eat() {
        System.out.println("男人在吃");
    }
}

Decorator

public abstract class Decorator implements Person {

    protected Person person;
    
    public void setPerson(Person person) {
        this.person = person;
    }
    
    public void eat() {
        person.eat();
    }
}

ConcreteDectrator

public class ManDecoratorA extends Decorator {

    public void eat() {
        super.eat();
        reEat();
        System.out.println("ManDecoratorA类");
    }

    public void reEat() {
        System.out.println("再吃一顿饭");
    }
}
public class ManDecoratorB extends Decorator {
    
    public void eat() {
        super.eat();
        System.out.println("===============");
        System.out.println("ManDecoratorB类");
    }
}

Test 

public class Test {

    public static void main(String[] args) {
        Man man = new Man();
        ManDecoratorA md1 = new ManDecoratorA();
        ManDecoratorB md2 = new ManDecoratorB();
        
        md1.setPerson(man);
        md2.setPerson(md1);
        md2.eat();
    }
}

 

7、装饰者模式小结

OO原则：动态地将责任附加到对象上。想要扩展功能， 装饰者提供有别于继承的另一种选择。

 

8、要点

1、继承属于扩展形式之一，但不见得是达到弹性设计的最佳方案。
2、在我们的设计中，应该允许行为可以被扩展，而不须修改现有的代码。
3、组合和委托可用于在运行时动态地加上新的行为。
4、除了继承，装饰者模式也可以让我们扩展行为。
5、装饰者模式意味着一群装饰者类， 这些类用来包装具体组件。
6、装饰者类反映出被装饰的组件类型（实际上，他们具有相同的类型，都经过接口或继承实现）。
7、装饰者可以在被装饰者的行为前面与/或后面加上自己的行为，甚至将被装饰者的行为整个取代掉，而达到特定的目的。
8、你可以有无数个装饰者包装一个组件。

 

9、 装饰者一般对组建的客户是透明的，除非客户程序依赖于组件的具体类型。

 

 

9、JDK中的装饰者模式

 java.io中很多使用了装饰者模式

 

举个例子:FilterInputStream继承(实现)了InputStream,同时,BufferedInputStream继承了FilterInputStream,

 

1, 被装饰者抽象组件：即最顶层的基类InputStream

 

2. 被装饰者具体实现ConcreteComponent：FileInputStream和FileOutputStream就是它的实现

 

3. 装饰者Decorator：FilterInputStream中有一个InputStream的实例和构造方法传入InputStream对象

protected volatile InputStream in;  
protected FilterInputStream(InputStream in) {
    this.in = in;
}

  4. 装饰者实现：在   BufferedInputStream  中有构造方法传入InputStream对象,实现了装饰

    

public BufferedInputStream(InputStream in, int size) {
    super(in);
    if (size <= 0) {
         throw new IllegalArgumentException("Buffer size <= 0");
    }
    buf = new byte[size];
}  

这个构造方法,对比上面的做面包流程,可以惊奇的发现是一模一样的. (可以将)

 

1.InputStream --> Person

    (这里就是InputStream,没什么好说的)

 

2.FileInputStream --> Man

 

3.FilterInputStream --> Decorator

  (实现Component,这里是InputStram.它里面必然有一个指向Component的引用,这个引用就是InputStream的实例)

 

4. BufferedInputStream  --> ManDecoratorA

    (装饰者实现,:用来装饰最基本的类,对I传入的nputStream进行了装饰)

 

  (BufferedInputStream 的super(in)就像CornDecorator中的kneadFlour()方法,也有super.kneadFlour(); ,只是这里IO流中用在了构造方法 )

这就是JDK中的装饰者模式