创建型模式 - 装饰器模式

1. 模式动机

一般有两种方式可以实现给一个类或对象增加行为：

• 继承机制，使用继承机制是给现有类添加功能的一种有效途径，通过继承一个现有类可以使得子类在拥有自身方法的同时还拥有父类的方法。但是这种方法是静态的，用户不能控制增加行为的方式和时机。
• 关联机制，即将一个类的对象嵌入另一个对象中，由另一个对象来决定是否调用嵌入对象的行为以便扩展自己的行为，我们称这个嵌入的对象为装饰器(Decorator)

装饰模式以对客户透明的方式动态地给一个对象附加上更多的责任，换言之，客户端并不会觉得对象在装饰前和装饰后有什么不同。装饰模式可以在不需要创造更多子类的情况下，将对象的功能加以扩展。这就是装饰模式的模式动机。

2. 模式定义

装饰模式(Decorator Pattern) ：动态地给一个对象增加一些额外的职责(Responsibility)，就增加对象功能来说，装饰模式比生成子类实现更为灵活。其别名也可以称为包装器(Wrapper)，与适配器模式的别名相同，但它们适用于不同的场合。根据翻译的不同，装饰模式也有人称之为“油漆工模式”，它是一种对象结构型模式。

3. 模式结构

装饰模式包含如下角色：

• Component: 抽象构件

• ConcreteComponent: 具体构件

• Decorator: 抽象装饰类

• ConcreteDecorator: 具体装饰类

  

4. 时序图

5. 代码分析

5.1.c++实现

#include 
using namespace std;class Component
{
public:virtual void operation() = 0;
};class ConcreteComponent : public Component
{
public:void operation(){cout << "ConcreteComponent::operation()" << endl;}
};class Decorator : public Component
{
public:Decorator(Component *pComponent){m_pComponent = pComponent;}virtual void operation(){m_pComponent->operation();}private:Component *m_pComponent;
};class ConcreteDecoratorA : public Decorator
{
public:ConcreteDecoratorA(Component *pcmp) : Decorator(pcmp){}void operation(){Decorator::operation();addBehavior();}void addBehavior(){cout << "ConcreteDecoratorA::addBehavior()" << endl;}
};class ConcreteDecoratorB : public Decorator
{
public:ConcreteDecoratorB(Component *pcmp) : Decorator(pcmp){}void operation(){Decorator::operation();addBehavior();}void addBehavior(){cout << "ConcreteDecoratorB::addBehavior()" << endl;}
};int main()
{Component *pComponent = new ConcreteComponent();ConcreteDecoratorA *pConcreteDecoratorA = new ConcreteDecoratorA(pComponent);pConcreteDecoratorA->operation();ConcreteDecoratorB *pConcreteDecoratorB = new ConcreteDecoratorB(pComponent);pConcreteDecoratorB->operation();return 0;
}

5.2.Golang实现

package mainimport "fmt"type Component interface {operation()
}type ConcreteComponent struct {
}func (c *ConcreteComponent) operation() {fmt.Println("ConcreteComponent::operation()")
}type Decorator struct {concreteComponent ConcreteComponent
}func (c *Decorator) operation() {c.concreteComponent.operation()
}type ConcreteDocoratorA struct {pecorator Decorator
}func (c *ConcreteDocoratorA) operation() {c.pecorator.operation()c.addBehavior()
}func (c *ConcreteDocoratorA) addBehavior() {fmt.Println("ConcreteDocoratorA::addBehavior()")
}type ConcreteDocoratorB struct {pecorator Decorator
}func (c *ConcreteDocoratorB) operation() {c.pecorator.operation()c.addBehavior()
}func (c *ConcreteDocoratorB) addBehavior() {fmt.Println("ConcreteDocoratorB::addBehavior()")
}func main() {ConcreteDocoratorA := new(ConcreteDocoratorA)ConcreteDocoratorA.operation()ConcreteDocoratorB := new(ConcreteDocoratorB)ConcreteDocoratorB.operation()
}

6. 模式分析

• 与继承关系相比，关联关系的主要优势在于不会破坏类的封装性，而且继承是一种耦合度较大的静态关系，无法在程序运行时动态扩展。在软件开发阶段，关联关系虽然不会比继承关系减少编码量，但是到了软件维护阶段，由于关联关系使系统具有较好的松耦合性，因此使得系统更加容易维护。当然，关联关系的缺点是比继承关系要创建更多的对象。
• 使用装饰模式来实现扩展比继承更加灵活，它以对客户透明的方式动态地给一个对象附加更多的责任。装饰模式可以在不需要创造更多子类的情况下，将对象的功能加以扩展。

7. 适用环境

在以下情况下可以使用装饰模式：

• 在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。
• 需要动态地给一个对象增加功能，这些功能也可以动态地被撤销。
• 当不能采用继承的方式对系统进行扩充或者采用继承不利于系统扩展和维护时。不能采用继承的情况主要有两类：第一类是系统中存在大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长；第二类是因为类定义不能继承（如final类）.

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！