设计模式 _第十一招式_装饰模式

痛定思痛。 2022-04-06 18:50 207阅读 0赞

## 一、定义 ##

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

## 二、代码演示 ##

2.1 通用类图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTE4MTQ5_size_16_color_FFFFFF_t_70]  
2.2 角色说明

*  Componet抽象构建  
    Componet是一个接口或者抽象类，及时我们定义最核心的对象，也是最原始的对象。
 *  ConcreteComponent具体构建  
    ConcreteComponent 是最核心，最原始，最基本的几口或者抽象类的实现，要装饰的及时它。
 *  Decorator装饰角色  
    一般是一个抽象类，做什么用的呢 ？实现接口或抽象方法，它里面不一定有抽象的方法，它的属性里必然有一个private变量纸箱Component抽象构建。
 *  具体装饰角色  
    ConcreteComponent A 和ConcreteComponent B是两个具体的装饰类，是要把你最核心的、原始的、最基本的东西装饰成其它东西。

2.3 抽象构建

/**
     * @description 抽象构建
     */
    public abstract class Component {
        //抽象的方法
        public  abstract  void operate();
    }

2.4 具体构建

/**
     * @description 具体构建
     */
    public class ConcreteComponent extends Component {
        //具体构建
        @Override
        public void operate(){
            System.out.println("ConcreteComponent do Something");
        }
    }

2.5 抽象装饰者

/**
     * @description 抽象装饰者
     */
    public abstract class Decorator extends Component {
        private  Component  component = null ;
        //通过构造函数传递被修饰者
        public  Decorator(Component _component ){
             this.component = _component ;
        }
        //委托给被修饰者执行
        @Override
        public  void operate(){
            this.component.operate();
        }
    }

2.6 具体装饰类

/**
     * @description 具体装饰类
     */
    public class ConcreteComponentA extends  Decorator{
        //定义装饰者
        public  ConcreteComponentA(Component _component){
            super(_component);
        }
        //定义自己的修饰方法
        private void method1(){
            System.out.println("method1 修饰");
        }
        //重新父类的operation方法
        public void operate(){
            this.method1();
            super.operate();
        }
    }

/**
     * @description 具体装饰类
     */
    public class ConcreteComponentB extends  Decorator{
        //定义装饰者
        public ConcreteComponentB(Component _component){
            super(_component);
        }
        //定义自己的修饰方法
        private void method2(){
            System.out.println("method2 修饰");
        }
        //重新父类的operation方法
        public void operate(){
            this.method2();
            super.operate();
        }
    }

2.7 场景类

/**
     * @description TODO
     */
    public class Client {
        public static void main(String args[]){
            Component  component = new ConcreteComponent();
            //第一次修饰
            component  = new ConcreteComponentA(component);
            //第二次修饰
            component  = new ConcreteComponentB(component);
            //修饰后运行
            component.operate();
        }
    }

2.8 运行结果

method2 修饰
    method1 修饰
    ConcreteComponent do Something

## 三、优点 ##

3.1 装饰类和被装饰类可以独立发展，而不会相互耦合。换句话说，Component类无须知道Decorator类，Decorator是从外部扩展Component类的功能，而Decorator也不知道具体的构建。  
3.2 装饰模式是继承关系的一个替代方案。我们看装饰类Decorator，不管封装了多少层，返回的对象还是Component，实现还是is-a的关系。  
3.3 装饰模式可以动态扩展一个实现类的功能，这不需要多说，装饰模式的定义如此。

## 四、缺点 ##

多层的装饰是比较复杂的。排查问题就得像剥洋葱一样，一层层的剥，排查问题的工作量大。因此尽量减少装饰类的数量，以便降低系统的复杂度。

## 五、应用场景 ##

*  需要扩展一个类的功能或一个类增加附加功能。
 *  需要给一个类动态的添加功能且这些功能动态的撤销。
 *  需要为一批兄弟类进行改装或加装功能，当然首选装饰模式。

## 六、注意事项 ##

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTE4MTQ5_size_16_color_FFFFFF_t_70]: /images/20220406/a012047c42f646898968c053c329ce1f.png