前言:最近在看面向对象程序设计时,遇到了几个新鲜的设计模式于是查了查资料,最终把他搞明白了,还是很开心的。。。
桥接模式
桥接模式的定义是这样的:
1、GOF四人帮在《设计模式:可复用面向对象软件的基础》一书中是这样描述的(见下引用),现在听起来感觉云里雾里的,不要在这里纠结,我们接着往下。
将抽象部分和它的实现部分分离,使它们都可以独立的变化。简单粗暴的说,就是抽象对外提供调用的接口;对外隐瞒实现部分,在抽象中引用实现部分,从而实现抽象对实现部分的调用,而抽象中引用的实现部分可以在今后的开发过程中,切换成别的实现部分(《设计模式:可复用面向对象软件的基础》)
2、《大话设计模式》一书中是这样描述的(见下引用)
将抽象部分与他的实现部分分离,使他们都可以独立的变化(《大话设计模式》)
UML类图
实例
1、绘制红色的长方形、白色的圆形(Jelly Young:C++设计模式——桥接模式)
/*
** FileName : BridgePatternDemo
** Author : Jelly Young
** Date : 2013/12/4
** Description : More information (http://www.jellythink.com/)
** Author : Aidan Dai
** Date : 2015/11/20
** Description : 添加注释(http://www.jellythink.com/archives/132)
*/
#include <iostream>
using namespace std;
/*
** 实现(颜料)
*/
class Implementor
{
public:
virtual void OperationImpl() = 0;
};
/*
** 具体实现(黄色颜料、绿色颜料、蓝色颜料)
*/
class ConcreteImpementor : public Implementor
{
public:
void OperationImpl()
{
cout << "OperationImpl" << endl;
}
};
/*
** 抽象(平面图形)
** 维护一个指向具体实现的指针(黄色颜料、绿色颜料、蓝色颜料)
*/
class Abstraction
{
public:
Abstraction(Implementor *pImpl) : m_pImpl(pImpl){}
virtual void Operation() = 0;
protected:
Implementor *m_pImpl;
};
/*
** 被提炼的抽象(圆形、正方形、长方形)
*/
class RedfinedAbstraction : public Abstraction
{
public:
RedfinedAbstraction(Implementor *pImpl) : Abstraction(pImpl){}
void Operation()
{
m_pImpl->OperationImpl();
}
};
int main(void)
{
Implementor *pImplObj = new ConcreteImpementor();
Abstraction *pAbsObj = new RedfinedAbstraction(pImplObj);
pAbsObj->Operation();
delete pImplObj;
pImplObj = NULL;
delete pAbsObj;
pAbsObj = NULL;
return 0;
}
2、手机软件何时统一(《大话设计模式》)
#include <iostream>
#include <string>
using namespace std;
class Implementor{
public:
void virtual Operation() = 0;
};
class ConcreteImplementorA : public Implementor{
public:
void Operation(){
cout << "ConcreteImplementorA" << endl;
}
};
class ConcreteImplementorB : public Implementor{
public:
void Operation(){
cout << "ConcreteImplementorB" << endl;
}
};
class Abstraction{
public:
void SetImplementor(Implementor *implementor){
this->m_implementor = implementor;
}
void virtual Operator() = 0;
protected:
Implementor *m_implementor;
};
class RefinedAbstraction : public Abstraction{
public:
void Operator(){
this->m_implementor->Operation();
}
};
int main(void){
Abstraction *abstraction = new RefinedAbstraction();
Implementor *implementor1 = new ConcreteImplementorA();
abstraction->SetImplementor(implementor1);
abstraction->Operator();
Implementor *implementor2 = new ConcreteImplementorB();
abstraction->SetImplementor(implementor2);
abstraction->Operator();
delete abstraction;
abstraction = NULL;
delete implementor1;
implementor1 = NULL;
delete implementor2;
implementor2 = NULL;
return 0;
}
3、自由切换家用电器开关(我给媳妇解释设计模式:第一部分(译文))
#include <iostream>
#include <string>
using namespace std;
class Equipment{
public:
void virtual poweron(string switchName) = 0;
void virtual poweroff(string switchName) = 0;
};
class Fan :public Equipment{
public:
void poweron(string switchName){
cout << "poweron Fan by " << switchName << endl;
}
void poweroff(string switchName){
cout << "poweroff Fan by " << switchName << endl;
}
};
class Light :public Equipment{
public:
void poweron(string switchName){
cout << "poweron Light by " << switchName << endl;
}
void poweroff(string switchName){
cout << "poweroff Light by " << switchName << endl;
}
};
class Switch{
public:
Switch(Equipment *equipment){
this->m_equipment = equipment;
}
void virtual on() = 0;
void virtual off() = 0;
Equipment *m_equipment;
};
class NormalSwitch :public Switch{
public:
NormalSwitch(Equipment *equipment) :Switch(equipment){
this->m_switchName = "NormalSwitch";
}
void on(){
this->m_equipment->poweron(this->m_switchName);
}
void off(){
this->m_equipment->poweroff(this->m_switchName);
}
private:
string m_switchName;
};
class FancySwitch :public Switch{
public:
FancySwitch(Equipment *equipment) :Switch(equipment){
this->m_switchName = "FancySwitch";
}
void on(){
this->m_equipment->poweron(this->m_switchName);
}
void off(){
this->m_equipment->poweroff(this->m_switchName);
}
private:
string m_switchName;
};
int main(void){
Equipment *equipment1 = new Fan();
Equipment *equipment2 = new Light();
Switch *equipmentSwitch1 = new NormalSwitch(equipment1);
Switch *equipmentSwitch2 = new FancySwitch(equipment2);
Switch *equipmentSwitch3 = new NormalSwitch(equipment1);
Switch *equipmentSwitch4 = new FancySwitch(equipment2);
equipmentSwitch1->on();
equipmentSwitch1->off();
equipmentSwitch2->on();
equipmentSwitch2->off();
equipmentSwitch3->on();
equipmentSwitch3->off();
equipmentSwitch4->on();
equipmentSwitch4->off();
delete equipment1;
equipment1 = NULL;
delete equipment2;
equipment2 = NULL;
delete equipmentSwitch1;
delete equipmentSwitch2;
delete equipmentSwitch3;
delete equipmentSwitch4;
equipmentSwitch1 = NULL;
equipmentSwitch2 = NULL;
equipmentSwitch3 = NULL;
equipmentSwitch4 = NULL;
return 0;
}
总结
is a 和 has a
1、理解继承:
- 对象的继承关系是在编译时就定义好了,所以无法再无法再运行时改变从父类继承的实现。子类的实现与它的父类有非常紧密的的依赖关系,以至于父类的实现中的任何变化必然会导致子类发生变化。当你需要复用子类时,如果继承下来的实现不适合解决新的问题,则父类必须重写或被其他更适合的类替换。这种依赖关系限制了灵活性并最终限制了复用性。
2、理解合成/聚合复用原则
- 合成/聚合复用原则:聚合表示一种弱的“拥有”关系,体现的是A对象可以包含B对象,但B对象不是A对象的一部分;合成则是一种强的“拥有”关系,体现了严格的部分和整体的关系,部分和整体的生命周期是一样的[DRE]。
就像大雁、翅膀和雁群的关系:
3、降低代码耦合度
4、通过实例不断的运用
结束语:
梦想还是要有的,万一实现了了呢!