大话设计模式06----装饰模式

大话设计模式

1 UML图

2 装饰模式C++代码实现

//Component类
class Component
{
public:
	virtual void Operation()
	{
		cout << "Component" << endl;
	}
};

//ConcreteComponent类
class ConcreteComponent:public Component
{
public:
	void Operation() override
	{
		cout << "具体对象的操作" << endl;
	}
};

//Decorator类
class Decorator :public Component
{
protected:
	Component component;

public:
	void SetComponent(Component com)//设置Component
	{
		component = com;
	}

	void Operation() override//重写Operation，实际执行的是Component的Operation
	{
		if (component != null)
		{
			component.Operation();
		}
	}
};

//ConcreteDecoratorA类
class ConcreteDecoratorA :public Decorator
{
private:
	string addedState;//本类独有的功能，以区别于ConcreteDecoratorB

public:
	//首先运行原Component的Operation，再执行本类的功能，如addedState，相当于对原有的Component进行了装饰
	void Operation() override
	{
		base.Operatiron();
		addedState = "New State";
		cout << "具体装饰对象A的操作" << endl;
	}
	
};

//ConcreteDecoratorB类
class ConcreteDecoratorB :public Decorator
{
public:
	//首先运行原Component的Operation，再执行本类的功能，如AddedBehavior，相当于对原有的Component进行了装饰
	void Operation() override
	{
		base.Operatiron();
		AddedBehavior();
		cout << "具体装饰对象B的操作" << endl;
	}

private:
	void AddedBehavior()//本类独有的方法，以区别于ConcreteDecoratorA
	{
		cout << "装饰B的操作" << endl;
	}
};

//客户端代码
int main()
{
	ConcreteComponent c = new ConcreteComponent();
	ConcreteDecoratorA d1 = new ConcreteDecoratorA();
	ConcreteDecoratorB d2 = new ConcreteDecoratorB();

	//装饰方法是：首先用ConcreteComponent实例化对象c，然后用ConcreteComponentA的实例化对象d1来包装c，
	//再用ConcreteComponentB的对象d2包装d1，最终执行d2的Operation
	d1.SetComponent(c);
	d2.SetComponent(d1);
	d2.Operation();

	return 0;
}

3 对于装饰模式的解释

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

建造模式和装饰着模式的区别：通过装饰模式可以让一个人的装饰有无数种方案，并非是固定的，而建造者模式要求建造的过程必须是稳定的。

装饰着模式的各个类扮演的角色：

• Component是定义一个对象，可以给这些对象动态地添加职责。
• ConcreteComponent是定义了一个具体的对象，也可以给这个对象增加一些职责。
• Decorator，装饰抽象类，继承了Component，从外类来扩展Component类的功能，但是对于Component来说，是无需知道Decorator的存在的。
• 至于ConcreteDecorator就是具体的装饰对象，起到给Component添加职责的作用。

装饰模式是利用SetComponent来对对象进行包装的。这样每个装饰对象的实现就和如何使用这个对象分开了，每个装饰对象只关心自己的功能，不需要关心何如被添加到对象链当中【DPE】。

如果只有一个ConcreteComponent类么没有抽象的Component类，那么Decorator类可以是ConcreteComponent的一个子类。同样道理，如果只有一个ConcreteDecorator类，那么就没有必要建立一个单独的Decorator类，而可以把Decorator和ConcreteComponent的责任合并成一个类。

装饰模式是为已有动能动态的添加更多功能的一种方式。

什么时候用：

• 需要在内部组装完成再显示出来的情况。
• 类似于建造者模式，但是建造者模式的要求见到的过程必须是稳定的，而装饰模式的建造过程是不稳定的。
• 我们需要把所需的功能按正确的顺序串联起来进行控制。

优点：

• 把类的装饰功能从类中搬移去除，这样可以简化原有的类。
• 有效地把类的核心职责和装饰功能区分开来，而且可以去除相关类中重复的装饰逻辑。

4 C++实现

UML图：

C++源代码：

#include<iostream>
#include<string>

using namespace std;

//Person类（ConcreteComponent）
class Person
{
private:
	string name;
	
public:
	Person(){}

	Person(string na)
	{
		name = na;
	}

	virtual void show()
	{
		cout << "装扮的" << name << endl;
	}
};

//服饰类（Decorator）
class Finery :public Person
{
protected:
	Person *component;

public:
	void setComponent(Person *per)
	{
		component = per;
	}

	void show() override
	{
		if (component != nullptr)
			component->show();
	}
};

//具体服饰类
class TShirts :public Finery
{
public:
	void show() override
	{
		cout << "大T恤 ";
		Finery::show();
	}
};

class BigTrouser :public Finery
{
public:
	void show() override
	{
		std::cout << "垮裤  ";
		Finery::show();
	}

};

class Sneakers :public Finery
{
public:
	void show() override
	{
		std::cout << "破球鞋  ";
		Finery::show();
	}

};

class Suit :public Finery
{
public:
	void show() override
	{
		std::cout << "西装  ";
		Finery::show();
	}

};

class Tie :public Finery
{
public:
	void show() override
	{
		std::cout << "领带  ";
		Finery::show();
	}

};

class LeatherShoes :public Finery
{
public:
	void show()
	{
		std::cout << "皮鞋  ";
		Finery::show();
	}
};

//客户端代码
int main()
{
	Person *per = new Person("小菜");
	cout << "第一种装扮:" << endl;

	Sneakers *sneakers = new Sneakers();
	BigTrouser *bigTrouser = new BigTrouser();
	TShirts *tShirts = new TShirts();

	sneakers->setComponent(per);
	bigTrouser->setComponent(sneakers);
	tShirts->setComponent(bigTrouser);
	tShirts->show();

	cout << "\n第二种装扮:" << endl;

	LeatherShoes* px = new LeatherShoes();
	Tie* ld = new Tie();
	Suit* xz = new Suit();

	px->setComponent(per);
	ld->setComponent(px);
	xz->setComponent(ld);

	xz->show();

	if (per != NULL)
	{
		delete per;
		per = NULL;
	}
	if (sneakers != NULL)
	{
		delete sneakers;
		sneakers = NULL;
	}
	if (tShirts != NULL)
	{
		delete tShirts;
		tShirts = NULL;
	}
	if (bigTrouser != NULL)
	{
		delete bigTrouser;
		bigTrouser = NULL;
	}
	if (px != NULL)
	{
		delete px;
		px = NULL;
	}
	if (ld != NULL)
	{
		delete ld;
		ld = NULL;
	}
	if (xz != NULL)
	{
		delete xz;
		xz = NULL;
	}

	cout << endl;
	system("pause");
	return 0;
}

运行结果：

第一种装扮:
大T恤 垮裤  破球鞋  装扮的小菜

第二种装扮:
西装  领带  皮鞋  装扮的小菜

请按任意键继续. . .

注意：在这里我们没有必要有Component类，直接让服饰类Decorator继承人类ConcreteComponent就可以了！