12. 装饰模式

一、装饰模式

装饰模式（Decorator Pattern），也叫包装器模式（Wrapper Pattern），是一种设计模式。它可以在不改变一个对象本身功能的基础上，动态地给该对象增加一些额外的功能或职责。

装饰模式是一个通过组合的方式替代继承的技术，它通过一种无须定义子类的方式来给对象动态增加职责，使用对象之间的关联关系取代类之间的继承关系。在装饰模式中引入了装饰类，在装饰类中既可以调用待装饰的原有类的方法，还可以增加新的方法，以扩充原有类的功能。

在装饰模式中，为了让系统具有更好的灵活性和可扩展性，通常会定义一个抽象装饰类，而将具体的装饰类作为它的子类。具体的装饰类则继承自抽象装饰类，并在其中添加新的行为或责任。客户端代码通过装饰类来访问原始对象，从而在不修改原始对象的情况下增加新功能。

装饰模式中的角色如下：

抽象构件角色（Component）：它是具体构件和抽象装饰类的共同父类，声明了在具体构件中实现的业务方法。它的引入可以使客户端以一致的方式处理未被装饰的对象以及装饰之后的对象，实现客户端的透明操作。
具体构件角色（Concrete Component）：它是抽象构件类的子类，用于定义具体的构件对象，实现了在抽象构件中声明的方法，装饰器可以给它增加额外的职责（方法）。
抽象装饰角色（Decorator）：它也是抽象构件类的子类，用于给具体构件增加职责，但是具体职责在其子类中实现。它维护一个指向抽象构件对象的引用，通过该引用可以调用装饰之前构件对象的方法，并通过其子类扩展该方法，以达到装饰的目的。
具体装饰角色（Concrete Decorator）：它是抽象装饰类的子类，负责向构件添加新的职责。每一个具体装饰类都定义了一些新的行为，可以调用在抽象装饰类中定义的方法，并可以增加新的方法用以扩充对象的行为。

由于具体构件类和装饰类都实现了相同的抽象构件接口，因此装饰模式以对客户透明的方式动态地给一个对象附加上更多的责任。换言之，客户端并不会觉得对象在装饰前和装饰后有什么不同。装饰模式可以在不需要创造更多子类的情况下，将对象的功能加以扩展。

二、C++实现装饰模式

装饰模式

抽象构件角色是具体构件和抽象装饰类的共同父类，声明了在具体构件中实现的业务方法。

// 抽象构件类
class Drink
{
private:
    std::string name;
    double price;
    std::string decsription;

public:
    Drink(std::string name, double price);

    virtual void describe(void) = 0;

    std::string getName(void);
    void setName(std::string name);

    double getPrice(void);
    void setPrice(double price);

    std::string getDecsription(void);
    void setDecsription(std::string decsription);
};

Drink::Drink(std::string name, double price) :name(name), price(price){}

std::string Drink::getName(void)
{
    return this->name;
}

void Drink::setName(std::string name)
{
    this->name = name;
}

double Drink::getPrice(void)
{
    return this->price;
}

void Drink::setPrice(double price)
{
    this->price = price;
}

std::string Drink::getDecsription(void)
{
    return this->decsription;
}

void Drink::setDecsription(std::string decsription)
{
    this->decsription = decsription;
}

具体构件角色是抽象构件类的子类，用于定义具体的构件对象，实现了在抽象构件中声明的方法，装饰器可以给它增加额外的职责（方法）。

// 具体构件类
class Coffee : public Drink
{
public:
    using Drink::Drink;

    void describe(void) override;
};

void Coffee::describe(void)
{
    setDecsription("饮品: " + getName() + ", 价格：" + std::to_string(getPrice()));
    std::cout << getDecsription() << std::endl;
}

抽象装饰类也是抽象构件类的子类，用于给具体构件增加职责，但是具体职责在其子类中实现。它维护一个指向抽象构件对象的引用，通过该引用可以调用装饰之前构件对象的方法，并通过其子类扩展该方法，以达到装饰的目的。

// 抽象装饰类
class Flavour : public Drink
{
private:
    Drink * drink;

public:
    Flavour(Drink * drink, std::string name, int price);

    double cost(void);
    void describe(void);

    Drink * getDrink(void);
    void setDrink(Drink * drink);
};

Flavour::Flavour(Drink * drink, std::string name, int price) : drink(drink), Drink(name, price){}

double Flavour::cost(void)
{
    setPrice(getDrink()->getPrice() + this->getPrice());
    return getPrice();
}

void Flavour::describe(void)
{
    setDecsription(getDrink()->getDecsription() + ", 添加: " + getName() + ", 价格：" + std::to_string(this->cost()));
    std::cout << getDecsription() << std::endl;
}

Drink * Flavour::getDrink(void)
{
    return this->drink;
}

void Flavour::setDrink(Drink * drink)
{
    this->drink = drink;
}

具体装饰类是抽象装饰类的子类，负责向构件添加新的职责。每一个具体装饰类都定义了一些新的行为，可以调用在抽象装饰类中定义的方法，并可以增加新的方法用以扩充对象的行为。

// 具体装饰类
class Milk : public Flavour
{
public:
    using Flavour::Flavour;
};

// 具体装饰类
class Chocolate : public Flavour
{
public:
    using Flavour::Flavour;
};

main() 函数：

#include <iostream>

int main(void)
{
    Drink * drink = new Coffee("咖啡", 10);
    drink->describe();

    drink = new Milk(drink, "牛奶", 2);
    drink->describe();

    drink = new Chocolate(drink, "巧克力", 3);
    drink->describe();

    return 0;
}

三、透明装饰模式与半透明装饰模式

由于新增行为可能需要单独调用，因此这种形式的装饰模式也经常出现，称为 半透明装饰模式（Semi-transparent）。而标准的装饰模式是 透明装饰模式（Transparent）。

在 透明装饰模式 中，要求客户端完全针对抽象编程。装饰模式的透明性要求客户端程序不应该将对象声明为具体构件类型或具体装饰类型，而应该全部声明为抽象构件类型。透明装饰模式可以让客户端透明地使用装饰之前的对象和装饰之后的对象，无须关心它们的区别。此外，还可以对一个已装饰过的对象进行多次装饰，得到更为复杂、功能更为强大的对象。

透明装饰模式的设计难度较大，而且有时用户需要单独调用新增的业务方法。为了能够调用到新增方法，不得不用具体装饰类型来定义装饰之后的对象，而具体构件类型还是可以使用抽象构件类型来定义，这种装饰模式即为 半透明装饰模式。也就是说，对于客户端而言，具体构件类型无须关心，是透明的；但是具体装饰类型必须指定，这是不透明的。

四、装饰模式的总结

装饰模式降低了系统的耦合度，可以动态地增加或删除对象的职责，并使得需要装饰的具体构件类和具体装饰类可以独立变化，以便增加新的具体构件类和具体装饰类。

4.1、装饰模式的优点

对于扩展一个对象的功能，装饰模式比继承更加灵活性，不会导致类的个数急剧增加。
可以通过一种动态的方式来扩展一个对象的功能。通过配置文件可以在运行时选择不同的具体装饰类，从而实现不同的行为。
可以对一个对象进行多次装饰。通过使用不同的具体装饰类以及这些装饰类的排列组合，可以创造出很多不同行为的组合，得到功能更为强大的对象。
具体构件类与具体装饰类可以独立变化，用户可以根据需要增加新的具体构件类和具体装饰类，原有类库代码无须改变，符合开闭原则。

4.2、装饰模式的缺点

使用装饰模式进行系统设计时将产生很多小对象。这些对象的区别在于它们之间相互连接的方式有所不同，而不是它们的类或者属性值有所不同。大量小对象的产生势必会占用更多的系统资源，在一定程度上影响程序的性能。
装饰模式提供了一种比继承更加灵活机动的解决方案，但同时也意味着比继承更加易于出错，排错也很困难。对于多次装饰的对象，调试时寻找错误可能需要逐级排查，较为烦琐。

4.3、装饰模式的适用场景

在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。
当不能采用继承的方式对系统进行扩展或者采用继承不利于系统扩展和维护时可以使用装饰模式。

4.4、装饰模式的注意事项

尽量保持装饰类的接口与被装饰类的接口相同。这样，对于客户端而言，无论是装饰之前的对象还是装饰之后的对象都可以一致对待。也就是说，在可能的情况下，应该尽量使用透明装饰模式。
尽量保持具体构件类是一个 “轻” 类。也就是说，不要把太多的行为放在具体构件类中，可以通过装饰类对其进行扩展。
如果只有一个具体构件类，那么抽象装饰类可以作为该具体构件类的直接子类。

posted @ 2023-09-07 19:54 星光映梦阅读(21) 评论(0) 编辑收藏举报

刷新页面返回顶部

FlurryHeart