装饰者模式(十三)

一、定义

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


二、类图及各角色


1. Component 抽象组件(公共接口/抽象类)

    装饰者模式必须要有这样一个抽象的组件,被装饰者和装饰者都是这个抽象的具体实现。往往定义我们最核心、最原始、最基本的对象。

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

2. ConcreteComponent 具体组件(被修饰者)

    ConcreteComponent 是最核心、最原始、最基本的接口或抽象类的实现,即被修饰者。
public class ConcreteComponent extends Component {
    //具体实现
    @Override
    public void operate() {
        System.out.println("do Something");
    }
}

3. Decorator 修饰者

    一般我们会定义一个抽象类作为修饰者的共同父类(当然,如果这有一个修饰者的话,我们也是可以省略掉这个抽象的父类的),修饰者除了实现共同接口外,还会持有一个 Component 的实例。

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

4. ConcreteDecorator 具体修饰者

    即 Decorator 抽象类的具体实现类

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();
    }
}

    最后我们可以模拟一个场景来调用,看看装饰者模式是如何运转的

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

三、优缺点

  • 优点:
  1. 动态的扩展一个类的功能,相比起继承,不管装饰多少层,它都不会产生深层继承的关系(继承层次很高后,代码是很难控制的)。
  2. 装饰者和被装饰者可以独立发展,而不会互相耦合。即 Component 类无须知道 Decorator 类, Decorator 类是从外部来扩展 Component 类的功能, 而 Decorator 也不用知道具体的构件。
  • 缺点:
  1. 装饰太多后,会产生很多相似的对象,不易拍错。应当尽量减少装饰类的数量,降低系统复杂度。


四、使用场景

  1. 需要扩展一个类的功能, 或给一个类增加附加功能。
  2. 需要动态地给一个对象增加功能, 这些功能可以再动态地撤销。
  3. 需要为一批的兄弟类进行改装或加装功能, 当然是首选装饰模式。


五、装饰者模式和代理模式

    也许大家还记得代理模式,的确,他们两者十分相似,装饰者其实就像一个特殊的代理。我的理解,装饰者侧重于扩展一个类或是对象的功能,代理者侧重于对原有方法进行改进。我们也不必追求他们两者之间的具体差别。


查看更多:设计模式分类以及六大设计原则

阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/afei__/article/details/80687585
文章标签: 装饰者模式
个人分类: 设计模式
所属专栏: 设计模式之禅
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭