【设计模式】装饰模式

1. 定义：

表示动态的给一个对象添加一些新的功能，但是比生成子类方式更灵活。(当然利用子类继承父类也可以实现,但是不推荐)

核心：动态地扩展一个实现类的功能。（装饰模式是继承关系的一个替换方案，不管装饰多少层，返回的对象构件角色）

2. 角色：

• 抽象构件（Component）角色：定义一个对象接口，可以给这些对象动态添加职责。
• 具体构件（ConcreteComponent）角色：是定义了一个具体的对象（例如：车），也可以给这个对象添加一些其他职责。
• 装饰（Decorator）角色：装饰抽象类，继承了Component，从外类来扩展Component类的功能，但对Component来说，是无需知道Decorator存在的。
• 具体装饰（ConcreteDecorator）角色：就是具体的装饰对象了（飞车，水车..），它起到了给Component添加职责的功能。

以Java IO流中的设计为例：

• 抽象构件角色——Input/OutputStream
• 具体构件角色——FileInput/OutputStream
• 装饰构件角色——FilterInput/OutputStream
• 具体装饰角色——BufferedInput/OutputStream，DataInput/OutputStream

接口Component，定义了基本职责

package DecoratorPattem;

/**
 * InputStream
 * @author Administrator
 *
 */
public interface Component {
     public void doThingA();
}

类ConcreteComponent，实现了Component中的功能

package DecoratorPattem;

public class ConcreteComponent implements Component{

     /**
      * FileInputStream
      * @param args
      */
     @Override
     public void doThingA(){
          System.out.println("Do A thing");
     }
}

类Decorator，是ConcreteComponent的具体实现类

package DecoratorPattem;

/**
 * FilterInputStream
 * @author Administrator
 *
 */
public class Decorator implements Component {
     private Component component=null;

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

     @Override
     public void doThingA() {
          component.doThingA();//调用被装饰对象的方法

     }
}

类ConcreteDecorator，对类Decorator做功能上的装饰。

package DecoratorPattem;


/*
 * BufferedInputStream
 */
public class ConcreteDecorator1 extends Decorator {

     public ConcreteDecorator1(Component component) {
          super(component);
     }
     @Override
     public void doThingA() {
          super.doThingA();//调用被包装类的方法
          doThingB();
     }

     //扩展功能
     private void doThingB(){
          System.out.println("Do B thing");
     }
}

package DecoratorPattem;

public class ConcreteDecorator2 extends Decorator {

     public ConcreteDecorator2(Component component) {
          super(component);
     }
     @Override
     public void doThingA() {
          super.doThingA();//调用被包装类的方法
          doThingC();
     }

     //扩展功能
     private void doThingC(){
          System.out.println("Do C thing");
     }
}