装饰模式

定义：动态的给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更为灵活。
我们先来看一下装饰模式的类图吧

这里有几个角色说明一下

1 . Component抽象组件
Component是一个接口或者抽象类，就是定义我们最核心的对象，也就是原始对象
2 . ConcreteComponent具体组件
ConcreteComponent是最核心、最原始、最基本的接口或抽象类的实现，你要装饰的就是它。
3 . Decorator装饰角色
一般是一个抽象类，里面有一个非常重要的private成员变量只想Component抽象组件
4.具体装饰角色
ConcreteDecorator1和ConcreteDecorator2都是

下面给出装饰模式的通用代码
1 . 抽象组件

public abstract class Component {
    //抽象的方法
    public abstract void operate();
}

2 . 具体组件

public class ConcreteComponent extends Component {

    //具体实现
    @Override
    public void operate() {
        System.out.println("do Something");
    }

}

3 . 抽象装饰者

public abstract class Decorator extends Component {
    private Component component = null;

    //通过构造函数传递被修饰者
    public Decorator(Component _component){
        this.component = _component;
    }

    //委托给被修饰者执行
    @Override
    public void operate() {
        this.component.operate();
    }

}

4 . 具体的装饰者

public class ConcreteDecorator1 extends Decorator {

    //定义被修饰者
    public ConcreteDecorator1(Component _component){
        super(_component);
    }

    //定义自己的修饰方法
    private void method1(){
        System.out.println("method1 修饰");
    }

    //重写父类的Operation方法
    public void operate(){
        this.method1();
        super.operate();
    }
}

public class ConcreteDecorator2 extends Decorator {

    //定义被修饰者
    public ConcreteDecorator2(Component _component){
        super(_component);
    }

    //定义自己的修饰方法
    private void method2(){
        System.out.println("method2修饰");
    }

    //重写父类的Operation方法
    public void operate(){
        super.operate();
        this.method2();
    }
}

5 . 场景类

public class Client {

    public static void main(String[] args) {
        Component component = new ConcreteComponent();

        //第一次修饰
        component = new ConcreteDecorator1(component);

        //第二次修饰
        component = new ConcreteDecorator2(component);

        //修饰后运行
        component.operate();

    }

}