设计模式：装饰者模式
装饰者模式么，在生活中我们是经常接触的。比如像我们这么快节奏的生活，好多都是早上去买煎饼。一般我们会这么说：“来一个粗粮煎饼，加两个鸡蛋，加一根肠”
或者：“来个山东煎饼，只加土豆丝”等等。“煎饼” 就是这个么个有弹性的对象，面饼是不变的，其它的像鸡蛋，肠什么的者在装饰面饼。这个也是我们编程时的一个设计原则
对扩展开放，对修改关闭。（在最后我会给出C# 和C++ 两种代码示例）
装饰者模式和“煎饼”差不多，它可以动态地将责任("鸡蛋“、“肠”...)附加到对象(”煎饼“)上。若要扩展功能，装饰者提供了比继承更有弹性的替代方案。
我们看一下装饰者模式的类图：
看这个类图我们可以总结一下装饰者模式的特点：
1.被装饰对象和装饰品有相同的接口。这样装饰品和被装饰对象就可以相互交互。
2.装饰品对象包含一个被装饰对象的引用。
让我们做一个煎饼吧：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace DecoratorDemo
{
[Flags]
public enum BcType
{
None = 0, // 0
SdCakeType, // 山东煎饼
EggType, // 蛋
SausageType // 肠
}
public interface IBatterCake
{
List<BcType> Type();
double Coast();
}
public class NoneBatterCake : IBatterCake
{
public List<BcType> Type()
{
return new List<BcType> {BcType.None};
}
public double Coast()
{
return 0;
}
}
/// <summary>
/// 山东煎饼
/// </summary>
public class SdBatterCake : IBatterCake
{
public List<BcType> Type()
{
return new List<BcType> {BcType.SdCakeType};
}
public double Coast()
{
return 3.5;
}
}
/// <summary>
/// 鸡蛋
/// </summary>
public class Egg : IBatterCake
{
private readonly IBatterCake _batterCake = new NoneBatterCake();
public Egg(IBatterCake mMoney)
{
_batterCake = mMoney;
}
public List<BcType> Type()
{
List<BcType> types = _batterCake.Type();
types.AddRange(new List<BcType>() { BcType.EggType });
return types;
}
public double Coast()
{
return 1 + _batterCake.Coast();
}
}
/// <summary>
/// 肠
/// </summary>
public class Sausage : IBatterCake
{
private readonly IBatterCake _batterCake = new NoneBatterCake();
public Sausage(IBatterCake mMoney)
{
_batterCake = mMoney;
}
public List<BcType> Type()
{
List<BcType> types = _batterCake.Type();
types.AddRange(new List<BcType>() { BcType.SausageType });
return types;
}
public double Coast()
{
return 2 + _batterCake.Coast();
}
}
/// <summary>
/// 计算花费
/// </summary>
public class CalculateMoney : IBatterCake
{
private readonly IBatterCake _batterCake = new NoneBatterCake();
public CalculateMoney(IBatterCake mMoney)
{
_batterCake = mMoney;
}
public List<BcType> Type()
{
return new List<BcType> {BcType.None};
}
public string Description()
{
List<BcType> types = _batterCake.Type();
int eggs = 0, sausage = 0,battercakies = 0;
for (int index = 0, count = types.Count(); index < count; index++)
{
if (types[index] == BcType.SdCakeType)
battercakies++;
if (types[index] == BcType.EggType)
eggs++;
if (types[index] == BcType.SausageType)
sausage++;
}
StringBuilder description = new StringBuilder();
if (battercakies > 0)
description.Append("煎饼").Append(battercakies).Append("个").Append("\n");
if (eggs > 0)
description.Append("鸡蛋").Append(eggs).Append("个").Append("\n");
if (sausage > 0)
description.Append("烤肠").Append(sausage).Append("个").Append("\n");
return description.ToString();
}
public double Coast()
{
return _batterCake.Coast();
}
}
public class Program
{
private static void Main(string[] args)
{
// 一个山东煎饼
IBatterCake sdBatterCake = new SdBatterCake();
// 一个鸡蛋
IBatterCake egg1 = new Egg(sdBatterCake);
// 再来个鸡蛋
IBatterCake egg2 = new Egg(egg1);
// 再来个肠
IBatterCake sausage = new Sausage(egg2);
CalculateMoney calculateMoney = new CalculateMoney(sausage);
Console.WriteLine(calculateMoney.Description());
Console.WriteLine("共花费 ： {0}", calculateMoney.Coast());
Console.ReadLine();
}
}
}看一下结果：
c++代码：
#include <iostream>
#include <string>
#include <list>
using namespace std;
enum class BcType
{
None = 0, // 0
SdCakeType, // 山东煎饼
EggType, // 蛋
SausageType // 肠
};
class IBatterCake
{
public:
virtual ~IBatterCake() {}
virtual list<BcType> type() const = 0;
virtual double coast() const = 0;
};
class NoneBatterCake : public IBatterCake
{
public:
NoneBatterCake() {}
virtual ~NoneBatterCake() { }
virtual list<BcType> type() const override
{
return list<BcType>{ BcType::None };
}
virtual double coast() const override
{
return 0;
}
};
/// <summary>
/// 山东煎饼
/// </summary>
class SdBatterCake : public IBatterCake
{
public:
SdBatterCake() {}
virtual ~SdBatterCake() { }
virtual list<BcType> type() const override
{
return list<BcType>{ BcType::SdCakeType };
}
virtual double coast() const override
{
return 3.5;
}
};
/// <summary>
/// 鸡蛋
/// </summary>
class Egg : public IBatterCake
{
public:
Egg() {}
Egg(IBatterCake *batter)
{
if (m_batter)
delete m_batter;
m_batter = batter;
}
~Egg()
{
delete m_batter;
}
virtual list<BcType> type() const override
{
list<BcType> ls = m_batter->type();
ls.push_back(BcType::EggType);
return ls;
}
virtual double coast() const override
{
return 3.5 + m_batter->coast();
}
private:
IBatterCake *m_batter = new NoneBatterCake();
};
/// <summary>
/// 肠
/// </summary>
class Sausage: public IBatterCake
{
public:
Sausage() {}
Sausage(IBatterCake *batter)
{
if (m_batter)
delete m_batter;
m_batter = batter;
}
~Sausage()
{
delete m_batter;
}
virtual list<BcType> type() const override
{
list<BcType> ls = m_batter->type();
ls.push_back(BcType::SausageType);
return ls;
}
virtual double coast() const override
{
return 2 + m_batter->coast();
}
private:
IBatterCake *m_batter = new NoneBatterCake();
};
/// <summary>
/// 计算花费
/// </summary>
class CalculateMoney : public IBatterCake
{
public:
CalculateMoney(IBatterCake *batter)
{
if (m_batter)
delete m_batter;
m_batter = batter;
}
~CalculateMoney()
{
delete m_batter;
}
virtual list<BcType> type() const override
{
return list<BcType>{ BcType::None };
}
string description()
{
list<BcType> types = m_batter->type();
int eggs = 0, sausage = 0, battercakies = 0;
for (const BcType &type : types) {
if (type == BcType::SdCakeType)
battercakies++;
if (type == BcType::EggType)
eggs++;
if (type == BcType::SausageType)
sausage++;
}
string description;
if (battercakies > 0)
description.append("煎饼").append(std::to_string(battercakies)).append("个\n");
if (eggs > 0)
description.append("加").append(std::to_string(eggs)).append("个鸡蛋\n");
if (sausage > 0)
description.append("加").append(std::to_string(sausage)).append("个烤肠\n");
return description;
}
virtual double coast() const override
{
return m_batter->coast();
}
private:
IBatterCake *m_batter = new NoneBatterCake();
};
int main()
{
IBatterCake *sdBatterCake = new SdBatterCake();
IBatterCake *egg1 = new Egg(sdBatterCake);
IBatterCake *egg2 = new Egg(egg1);
IBatterCake *sausage = new Sausage(egg2);
CalculateMoney *calculateMoney = new CalculateMoney(sausage);
cout << calculateMoney->description();
delete calculateMoney;
cin.get();
return 0;
}结果是一样的
以下情况使用Decorator模式
1. 需要扩展一个类的功能，或给一个类添加附加职责。
2. 需要动态的给一个对象添加功能，这些功能可以再动态的撤销。
3. 需要增加由一些基本功能的排列组合而产生的非常大量的功能，从而使继承关系变的不现实。
4. 当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。
本文参与 腾讯云自媒体分享计划，分享自作者个人站点/博客。
原始发表：2015-09-17 ，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读