结合I/O讲讲装饰模式（Decorator）

简介

• 装饰模式又名包装（Wrapper）模式
• 装饰模式以对客户透明的方式扩展对象（并非类）的功能，是继承关系的一个替代方案。
• 装饰模式以对客户透明的方式动态地给一个对象附加上更多的责任。换言之，客户端并不觉得对象在装饰前后有不同。
• 装饰模式可以在不创造更多子类的情况下，将对象的功能扩展。

装饰模式的角色：

• 抽象构件角色（Component）：给出一个抽象接口，以规范准备接收附加责任的对象。
  例如：InputStream
• 具体构件角色（Concrete Component）:定义一个将要接受附加责任的对象。
  例如：FileInputStream
• 装饰角色（Decorator）：持有一个构件（Component）对象的引用，并定义一个与抽象构件接口一致的接口。
  例如：FilterInputStream
• 具体装饰角色（Concrete Decorator）：负责给构件对象贴上附加的责任。
  例如：BufferedInputStream

装饰模式的特点

• 装饰对象和真实对象有相同的接口。这样客户端对象就可以以和真是对象相同的方式和装饰对象交互。
• 装饰对象包含一个真实对象的引用（reference）。意味着，装饰对象可以调用真实对象的方法。
• 装饰对象接收所有来自客户端的请求。它把这些请求转发给真实的对象。
• 装饰对象可以在转发这些请求以前或以后增加一些附加功能。这样就确保了在运行时，不用修改给定对象的结构就可以在外部增加附加的功能。在面向对象的设计中，通常是通过继承来实现对给定类的功能扩展。

一个简单的例子

抽象构件角色（Component）

public interface Component {
    void doSomething();
}

具体构件角色（ConcreteComponent）

public class ConcreteComponent implements Component {
    @Override
    public void doSomething() {
        System.out.println("功能A");
    }
}

装饰角色（Decorator）

public class Decorator implements Component {
    //包含一个抽象构件角色的引用
    private Component component;

    public Decorator(Component component){
        this.component = component;
    }
    @Override
    public void doSomething() {
        component.doSomething();
    }
}

具体装饰角色（ConcreteDecorator1）

public class ConcreteDecorator1 extends Decorator {

    public ConcreteDecorator1(Component component) {
        super(component);
    }

    @Override
    public void doSomething() {
        super.doSomething();
        this.doAnotherThing();
    }
	//增强的功能
    private void doAnotherThing() {
        System.out.println("功能B");
    }
}

具体装饰角色（ConcreteDecorator2）

public class ConcreteDecorator2 extends Decorator {

    public ConcreteDecorator2(Component component) {
        super(component);
    }

    @Override
    public void doSomething() {
        super.doSomething();
        this.doAnotherThing();
    }

    private void doAnotherThing() {
        System.out.println("功能C");
    }
}

客户端（Client）

public class Client {
    public static void main(String[] args) {
        Component component = new ConcreteDecorator2(
                new ConcreteDecorator1(
                        new ConcreteComponent()
                )
        );
        component.doSomething();
    }
}

最终输出的结果是：

功能A
功能B
功能C

优点

1、装饰器是继承的有力补充，比继承灵活，不改变原有对象的情况下动态地给一个对象扩展功能，即插即用。
2、通过使用不同装饰类以及这些装饰类的排列组合，可实现不同效果
3、装饰器完全遵守开闭原则。

缺点

1、会出现更多的代码，更多的类，增加程序复杂性
2、动态装饰时，多层装饰时会更复杂。

装饰模式VS继承

• 装饰模式

  • 用来扩展特定对象的功能。
  • 不需要子类，防止由于子类而导致的复杂和混乱。
  • 动态，运行时分派职责。
  • 更过的灵活性。对于一个给定的对象，客户端可以选择合适的装饰。

• 继承

  • 用来扩展一类对象的功能。
  • 需要子类。
  • 静态，编译时分派职责。
  • 缺乏灵活性。

装饰模式的适用性

• 想要透明并且动态地给对象增加新的职责（方法）而不影响其它对象。
• 给对象增加的职责在未来可能会发生改变。
• 用子类扩展功能不实际的情况下。

看看I/O中活生生的例子

额外提一下，这里为什么要用volatile，面试常考题：
1.做内存可见性的处理。当有多个线程的时候，每个线程会有自己的工作内存，此外还有一个总内存。如果一个线程修改了自己工作内存的变量值且不加volatile，在修改完的某瞬间，并不会更新到总内存。也就是其它线程看到的值没有变化。如果变量使用了volatile，会被立刻刷新到其它线程的工作内存。实际上，其它线程在处理被volatile修饰的变量的时候，会刷新一下自己的工作内存。
2.防止指令重排序。编译器为了优化代码，编译好的字节码定义的程序顺序可能和原来不一样，加上volatile可以避免。