java 装饰者模式 详解

二话不说，看代码先

package com.zq.designpattern;

import java.util.Random;

/**
 * Created by zhengshouzi on 2015/10/28.
 */

interface OutputStream{
    void write(String string);
}

class StringOutputStream implements OutputStream{

    @Override
    public void write(String string) {
        System.out.println("写  "+ string + "  到文件");
    }
}

abstract class FilterOutputStream implements OutputStream{


}
class EncryptString_1_OutputStream extends FilterOutputStream{
    OutputStream outputStream;

    public EncryptString_1_OutputStream(OutputStream outputStream){
        this.outputStream = outputStream;
    }
    @Override
    public void write(String string) {
        char[] chars = string.toCharArray();
        StringBuilder sb = new StringBuilder();
        System.out.println("源字符串:  "+string+"   开始简单加密（装饰）：每一字符自身加上1");
        for (int i=0;i<chars.length;i++){
            if (chars[i]!='z'){
                chars[i] = (char) (chars[i]+1);
            }else {
                chars[i] = 'a';
            }
            //System.out.print(chars[i]);
            sb.append(chars[i]);
        }
        System.out.println("随机加密后字符串：" + sb.toString());
        System.out.println("------------------------------------------------");
        outputStream.write(sb.toString());
    }
}

class EncryptString_2_OutputStream extends FilterOutputStream{
    OutputStream outputStream;
    public EncryptString_2_OutputStream(OutputStream outputStream){
        this.outputStream = outputStream;
    }
    @Override
    public void write(String string) {
        char[] chars = string.toCharArray();
        StringBuilder sb = new StringBuilder();
        System.out.println("源字符串:  "+string+"   开始自身加密（装饰）：每一字符加上自己然后除以3");
        for (int i=0;i<chars.length;i++){

            chars[i] = (char) ((chars[i]+chars[i])/3);
            //System.out.print(chars[i]);
            sb.append(chars[i]);
        }
        System.out.println("随机加密后字符串：" + sb.toString());
        System.out.println("------------------------------------------------");
        outputStream.write(sb.toString());
    }
}

class EncryptString_3_OutputStream extends FilterOutputStream{
    OutputStream outputStream;
    public EncryptString_3_OutputStream(OutputStream outputStream){
        this.outputStream = outputStream;
    }
    @Override
    public void write(String string) {
        char[] chars = string.toCharArray();
        StringBuilder sb = new StringBuilder();
        System.out.println("源字符串:  "+string+"   开始随机加密（装饰）：每一字符加上一个5以内的随机数");
        for (int i=0;i<chars.length;i++){

            chars[i] = (char) ((chars[i]+new Random().nextInt(5)-5));
            //System.out.print(chars[i]);
            sb.append(chars[i]);
        }
        System.out.println("随机加密后字符串：" + sb.toString());
        System.out.println("------------------------------------------------");
        outputStream.write(sb.toString());
    }
}
public class DecoratorPattern {
    public static void main(String[] args) {
        OutputStream outputStream = new StringOutputStream();

        EncryptString_1_OutputStream encryptString_1_outputStream = new EncryptString_1_OutputStream(outputStream);
        EncryptString_2_OutputStream encryptString_2_outputStream = new EncryptString_2_OutputStream(encryptString_1_outputStream);
        EncryptString_3_OutputStream encryptString_3_outputStream = new EncryptString_3_OutputStream(encryptString_2_outputStream);
        //encryptString_1_outputStream.write("output");
        encryptString_3_outputStream.write("zhengqiang");
    }
}

一共有三个用来加密的装饰者类，他们都能装饰原来的StringOutputStream 类，使原来的StringOutputStream具有各种想要的的功能，分别创建被装饰者，然后将被装饰者作为装饰者类的构造参数，这样完成了装饰功能。

         概述：

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

        类型：结构型模式。

         适用性：

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

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

        3、当不能采用生成子类的方法进行扩充时。

        参与者：

        1、Component（OutputStream接口）

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

        2、ConcreteComponent（StringOutputStream类）

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

        3、Decorator（）

        维持一个指向Component对象的指针，并定义一个与Component接口一致的接口。

        4、ConcreteDecorator（各个具体的加密类）

        向组件添加职责。

 装饰模式的优缺点

l          比继承更灵活
    从为对象添加功能的角度来看，装饰模式比继承来得更灵活。继承是静态的，而且一旦继承是所有子类都有一样的功能。而装饰模式采用把功能分离到每个装饰器当中，然后通过对象组合的方式，在运行时动态的组合功能，每个被装饰的对象，最终有哪些功能，是由运行期动态组合的功能来决定的。

l          更容易复用功能
    装饰模式把一系列复杂的功能，分散到每个装饰器当中，一般一个装饰器只实现一个功能，这样实现装饰器变得简单，更重要的是这样有利于装饰器功能的复用，可以给一个对象增加多个同样的装饰器，也可以把一个装饰器用来装饰不同的对象，从而复用装饰器的功能。

l          简化高层定义
    装饰模式可以通过组合装饰器的方式，给对象增添任意多的功能，因此在进行高层定义的时候，不用把所有的功能都定义出来，而是定义最基本的就可以了，可以在使用需要的时候，组合相应的装饰器来完成需要的功能。

l          会产生很多细粒度对象
    前面说了，装饰模式是把一系列复杂的功能，分散到每个装饰器当中，一般一个装饰器只实现一个功能，这样会产生很多细粒度的对象，而且功能越复杂，需要的细粒度对象越多。

  思考装饰模式

1：装饰模式的本质

装饰模式的本质：动态组合。

       动态是手段，组合才是目的。这里的组合有两个意思，一个是动态功能的组合，也就是动态进行装饰器的组合；另外一个是指对象组合，通过对象组合来实现为被装饰对象透明的增加功能。

       但是要注意，装饰模式不仅仅可以增加功能，也可以控制功能的访问，可以完全实现新的功能，还可以控制装饰的功能是在被装饰功能之前还是之后来运行等。

       总之，装饰模式是通过把复杂功能简单化，分散化，然后在运行期间，根据需要来动态组合的这么一个模式。

2：何时选用装饰模式

建议在如下情况中，选用装饰模式：

• 如果需要在不影响其它对象的情况下，以动态、透明的方式给对象添加职责，可以使用装饰模式，这几乎就是装饰模式的主要功能
• 如果不合适使用子类来进行扩展的时候，可以考虑使用装饰模式，因为装饰模式是使用的“对象组合”的方式。所谓不适合用子类扩展的方式，比如：扩展功能需要的子类太多，造成子类数目呈爆炸性增长。