27.1 代理模式 VS 装饰模式
27.1.1 代理模式
(1)场景:客人找运动员代理要求安排运动员参加比赛
(2)说明:代理人有控制权,可以拒绝客人的要求,也可以答应安排,甚至自己下去跑(因为有些运动员本身就作自己的代理)
【编程实验】找代理安排运动员比赛
//结构型模式大PK——代理模式和装饰模式
//实例:找代理安排运动员比赛
#include <iostream>
#include <ctime>
using namespace std;
//抽象运动员
class IRunner
{
public:
virtual void run() = 0;
virtual ~IRunner() {}
};
//运动员
class Runner : public IRunner
{
public:
void run()
{
cout << "运动员跑步,动作很潇洒" << endl;
}
};
//代理人(也与运动员一样,实现同一接口)
class RunnerAgent : public IRunner
{
Runner* runner;
public:
RunnerAgent(Runner* runner)
{
srand((int)time(NULL));
this->runner = runner;
}
void run()
{
if((rand() % 2) ==0)
{
cout << "代理人同意安排运动员跑步" << endl;
runner->run();
}
else
{
cout << "代理人心情不好,不安排运动员跑步" << endl;
}
}
};
int main()
{
//定义一个运动员
Runner* runner = new Runner();
//定义代理人
IRunner* agent = new RunnerAgent(runner);
//要求运动员跑步
cout << "===客人找到代理要求运动员去跑步" << endl;
//为演示,比如洽谈了10次
for(int i=0; i<10; i++)
{
cout <<"第" <<i+1 <<"次洽谈结果:";
agent->run();
cout << endl;
}
delete runner;
delete agent;
return 0;
};
27.1.2 装饰模式
(1)装饰模式:对类的功能进行加强
【编程实验】安装喷气装置
//结构型模式大PK——代理模式和装饰模式
//实例:为飞机安装喷气动力装置
#include <iostream>
#include <ctime>
using namespace std;
//飞行接口
class IFly
{
public:
virtual void fly() = 0;
virtual ~IFly() {}
};
//飞机
class AirPlane : public IFly
{
public:
void fly()
{
cout << "飞机正在飞行..." << endl;
}
};
//JetFly
class JetFly : public IFly
{
IFly* airPlane;
public:
JetFly(IFly* airPlane)
{
this->airPlane = airPlane;
}
void speedUp()
{
cout << "为飞机加装了喷气动力装置,正在加速中..." << endl;
}
void fly()
{
speedUp();
airPlane->fly();
}
};
int main()
{
//定义一架飞机
IFly* airPlane = new AirPlane();
//定义装饰类,对功能进行加强
IFly* jet = new JetFly(airPlane);
cout << "===增加功能后的飞机" << endl;
jet->fly();
delete jet;
delete airPlane;
return 0;
};
27.1.3 最佳实践
(1)装饰类对被装饰的类的行为没有决定权,只有增强作用。而代理可以控制对被代理人的访问。
(2)代理模式是把当前的行为或功能委托给其他对象执行,代理类负责接口限定(如是否可以调用真实角色,一般不对被代理功能当修饰,而是保证原汁原叶的调用。
(3)装饰模式在保证接口不变的情况下加强类的功能,它保证的是被修饰对象功能比原来丰富(当然也可以减弱),但不做准入条件和准入参数的过滤。
27.1.3 最佳实践
(1)装饰类对被装饰的类的行为没有决定权,只有增强作用。而代理可以控制对被代理人的访问。
(2)代理模式是把当前的行为或功能委托给其他对象执行,代理类负责接口限定(如是否可以调用真实角色,一般不对被代理功能当修饰,而是保证原汁原叶的调用。
(3)装饰模式在保证接口不变的情况下加强类的功能,它保证的是被修饰对象功能比原来丰富(当然也可以减弱),但不做准入条件和准入参数的过滤。
27.2 装饰模式 VS 适配器模式
27.2.1 用装饰模式描述丑小鸭
(1)丑小鸭首先是一只天鹅,具备了天鹅所有的行为和属性(即它从天鹅继承而来)
(2)只是小时候,又小、又脏,又不能飞行。随着时间推移,对其属性和行为进行加强,慢慢变成一只白天鹅。
【编程实验】丑小鸭变小天鹅的故事
//结构型模式大PK——装饰模式和适配器模式
//实例:丑小鸭变小天鹅
#include <iostream>
#include <ctime>
using namespace std;
//天鹅接口
class Swan
{
public:
virtual void fly() = 0; //会飞
virtual void cry() = 0; //会叫
virtual void Appearance() = 0; //外观
virtual ~Swan(){}
};
//丑小鸭(本质上是天鹅)
class UglyDuckling : public Swan
{
public:
//丑小鸭还比较小,不能飞
void fly()
{
cout << "不能飞" <<endl;
}
//丑小鸭的叫声
void cry()
{
cout << "叫声是克噜——克噜——克噜" << endl;
}
//丑小鸭的外形
void Appearance()
{
cout << "外形是脏兮兮的白色,毛毛茸茸的大脑袋" <<endl;
}
};
//装饰类
class Decorator : public Swan
{
private:
Swan* swan;
public:
Decorator(Swan* swan)
{
this->swan = swan;
}
void fly()
{
swan->fly();
}
void cry()
{
swan->cry();
}
void Appearance()
{
swan->Appearance();
}
};
//具体的装饰类(外形美化)
class BeautifyAppearance : public Decorator
{
public:
BeautifyAppearance(Swan* swan):Decorator(swan){}
//外表美化处理(重写该方法)
void Appearance()
{
//这里是重新实现,不再调用原来的Decorator::desAppearance()
cout << "外表是纯白色的,非常惹人喜爱" << endl;
}
};
//具体装饰类
class StrongBehavior :public Decorator
{
public:
StrongBehavior(Swan* swan):Decorator(swan){}
//会飞行了
void fly()
{
//这里是完全重新实现了被装饰类飞的功能。
cout << "会飞行了!" << endl;
}
};
int main()
{
cout <<"===很久很久以前,这里有一只丑陋的小鸭子===" << endl;
Swan* duckling = new UglyDuckling();
//展示一下小鸭
duckling->Appearance();
duckling->cry();
duckling->fly();
cout <<"===小鸭子终于发现自己是一只天鹅===" << endl;
//首先外形变化
BeautifyAppearance duckling2(duckling);
StrongBehavior duckling3(&duckling2);
duckling3.Appearance();
duckling3.cry();
duckling3.fly();
delete duckling;
return 0;
};
/*输出结果:
===很久很久以前,这里有一只丑陋的小鸭子===
外形是脏兮兮的白色,毛毛茸茸的大脑袋
叫声是克噜——克噜——克噜
不能飞
===小鸭子终于发现自己是一只天鹅===
外表是纯白色的,非常惹人喜爱
叫声是克噜——克噜——克噜
会飞行了!
*/
27.2.2 用适配器模式描述丑小鸭
(1)两个接口:鸭和天鹅。而丑小鸭就相当于适配器。
(2)为了演示适配器的使用,丑小鸭本质上是天鹅,所以应该把鸭子的接口转为天鹅的接口。即鸭子的源接口,目标接口为天鹅。以便让天鹅具备小鸭的一些特点。
【编程实验】一只与众不同的鸭子
//结构型模式大PK——装饰模式和适配器模式
//实例:一只与众不同的鸭子
#include <iostream>
#include <ctime>
using namespace std;
//天鹅接口
class Swan
{
public:
virtual void behavior() = 0; //其他行为,会飞
virtual void cry() = 0; //会叫
virtual void Appearance() = 0; //外观
};
//鸭子的接口
class Duck
{
public:
virtual void behavior() = 0; //会游泳
virtual void cry() = 0; //会叫
virtual void Appearance() = 0; //外观
virtual ~Duck(){}
};
//白天鹅
class WhiteSwan : public Swan
{
public:
void cry()
{
cout << "叫声是克噜——克噜——克噜" << endl;
}
void Appearance()
{
cout << "外形是纯白色,惹人喜爱" << endl;
}
//其他行为
void behavior()
{
cout << "能够飞行" << endl;
}
};
//小鸭子
class Duckling : public Duck
{
public:
void cry()
{
cout << "叫声是嘎——嘎——嘎" << endl;
}
void Appearance()
{
cout << "外形是黄白相间,嘴长" << endl;
}
//描述鸭子的其他行为
void behavior()
{
cout << "会游泳" << endl;
}
};
//丑小鸭相当于适配器的角色,丑小鸭本质上是天鹅,所以应该把鸭子
//的接口转为天鹅的接口。即鸭子的源接口,目标接口为天鹅
class UglyDuckling : public WhiteSwan
{
Duck* duck; //目标接口
public:
UglyDuckling(Duck* duck)
{
this->duck = duck;
}
//丑小鸭的叫声,直接从父类继承
//丑小鸭的外形,直接从父类继承
//其他行为
void behavior()
{
//本身会飞
WhiteSwan::behavior();
//学会鸭子的游泳
duck->behavior();
}
};
int main()
{
cout <<"===鸭妈妈有5个孩子,其中4个都是一个模样==="<< endl;
Duck* duck = new Duckling();
duck->cry();
duck->Appearance();
duck->behavior();
cout <<"===一只独特的小鸭子,模样是这样的==="<< endl;
UglyDuckling uglyDuckling(duck); //丑小鸭
uglyDuckling.cry();
uglyDuckling.Appearance();
uglyDuckling.behavior();
delete duck;
return 0;
};
/*输出结果:
===鸭妈妈有5个孩子,其中4个都是一个模样===
叫声是嘎——嘎——嘎
外形是黄白相间,嘴长
会游泳
===一只独特的小鸭子,模样是这样的===
叫声是克噜——克噜——克噜
外形是纯白色,惹人喜爱
能够飞行
会游泳
*/
27.2.3 最佳实践
(1)装饰模式包装的是自己的兄弟类,隶属于同一家族(相同的父类),而适配器模式则修饰的是非血缘关系类。把一个非本家族伪装成本家族的对象,注意是伪装,因此它的本质还是不同的接口对象。
(2)意图不同
装饰模式的意图是加强对象的功能,而适配器模式关注的是转化,两个对象之间的接口转化。
(3)所作用的对象不同
①装饰模式装饰的对象必须是自己的同宗,也就是相同的父类,只要在具有相同的属性和行为情况下,才能比较行为是增加或减弱。
②适配器模式则必须是两个不对象接口对象,因为它着重于转换
(4)场景不同
①装饰模式只要是想增强功能的,都可以用。
②适配器模式则是一个补救模式,一般出现在系统成熟或己经构建完毕的项目中,作为一个紧急处理手段采用。
(5)扩展性不同
装饰模式容易扩展,如果不需要修饰某对象了,可以随时拿掉,而且装饰类也可以继续扩展。但适配器模式就不同,它在两个不同对象之间架起一座沟通的桥染,建立容易,去掉时需要从系统整体考虑是否能够撤销。