设计模式--桥接模式

说起桥接模式，大家可能会联想到虚拟机中的桥接模式概念，在虚拟机中的桥接模式和设计模式中的桥接模式是完全两个不同的东西，没有可比性。只是在这里稍加提及两个概念而已。

桥接模式针对的应用目标是将一个对象中的实现功能部分和抽象部分从对象中进行分离出来。并且将抽象出来的两个部分分别各自进行封装成对象。总之，为了提高内聚度，降低模块之间的耦合度而所做的努力都是值得的。但是，至于具体如何提高内聚，降低耦合是一个关键性的问题，如何把握还得看具体情况。

桥接模式也是一个为了提高程序中的各个部分的内聚而设计出来的，将一个对象中可以进行分离的部分进行抽离，然后再度进行封装。以组合的方式以供调用，这样的处理的好处就是直接的降低了程序的耦合度，同时，也是程序的结构更加清晰可见。当然，任何东西都不能够适用于所有情况，如果一个对象中，抽象部分和实现部分本身之间的关联并不是很密切，如果使用桥接模式的话，可能会增加它的复杂度，所以视情况而定。

先画桥接模式的一个类图，如下：

从上图中可以看得出来，将抽象类和实现类都从原来对象中剥离出来，并且重新纷封装成对象。同时，对象可以有多种的实现方式，从这个角度上来讲，也间接的丰富了对象。

与之前的几个重要的设计模式想比较而言，从理解程度上来讲，要容易的多。例如之前的工厂模式、工厂方法模式等等，在理解和处理起来都不容易，尤其是像工厂模式和builder模式。

那么，在什么情况下用桥接模式比较合适呢？？在学习面向对象的时候，我们会发现，通过组合方式来实现一些东西往往比通过继承要来的更加方便。同时组合的数据耦合度很低。

就像是在一个汽车配件厂一样，我们的一辆汽车是通过各个不同的配件来完成的，而且每一个配件都属于汽车的一个部分，缺一不可。但是，在汽车出厂的最后一步，就是将汽车的各个部分进行装配起来，最后送出。如果从桥接模式来看的话，其实就相当于将汽车的各个部分进行剥离，各自封装成对象。例如：发动机系统，轮胎，车架等等。各自都进行各自对象的封装设计。最后通过组合的方式，完成一个完整的汽车的装配。

举一个实际的应用例子吧。

[cpp]
#ifndef CAR_H_
#define CAR_H_
class motor;
//汽车的类
class Car
{
public:
       voidsprit();
private:
       motor *pmotor;
};

#endif
#include"Car.h"
#include "motor.h"
#include <iostream>
using namespace std;
void Car::sprit()
{
       pmotor   =newCarmoter;
       pmotor->ApplyEnery();
       cout<<"这是一辆汽车"<<endl;
}

#pragma once
//发动机系统
class motor
{
public:
       motor(void);
       ~motor(void);
public:
       //提供动力
       virtualvoid ApplyEnery();
};
class Carmoter:publicmotor
{
public:
       Carmoter(void);
       ~Carmoter();
public:
       voidApplyEnery();
};
#include "motor.h"
#include <iostream>
using namespace std;
motor::motor(void)
{
}

motor::~motor(void)
{
}

void motor::ApplyEnery()
{
       cout<<"发动机系统"<<endl;
}

void Carmoter::ApplyEnery()
{
       cout<<"汽车发动机"<<endl;
}

Carmoter::Carmoter(void )
{

}

Carmoter::~Carmoter()
{

}
#include "Car.h"
#include "motor.h"
#include <iostream>
void main()
{
       Car *m_car =newCar;
       m_car->sprit();
}

#ifndef CAR_H_
#define CAR_H_
class motor;
//汽车的类
class Car
{
public:
       voidsprit();
private:
       motor *pmotor;
};

#endif
#include"Car.h"
#include "motor.h"
#include <iostream>
using namespace std;
void Car::sprit()
{
       pmotor   =newCarmoter;
       pmotor->ApplyEnery();
       cout<<"这是一辆汽车"<<endl;
}

#pragma once
//发动机系统
class motor
{
public:
       motor(void);
       ~motor(void);
public:
       //提供动力
       virtualvoid ApplyEnery();
};
class Carmoter:publicmotor
{
public:
       Carmoter(void);
       ~Carmoter();
public:
       voidApplyEnery();
};
#include "motor.h"
#include <iostream>
using namespace std;
motor::motor(void)
{
}

motor::~motor(void)
{
}

void motor::ApplyEnery()
{
       cout<<"发动机系统"<<endl;
}

void Carmoter::ApplyEnery()
{
       cout<<"汽车发动机"<<endl;
}

Carmoter::Carmoter(void )
{

}

Carmoter::~Carmoter()
{

}
#include "Car.h"
#include "motor.h"
#include <iostream>
void main()
{
       Car *m_car =newCar;
       m_car->sprit();
}

最后的运行结果为：

桥接模式最大的好处，就是将一个对象中的某些可以单独剥离的部分进行独立的对象封装，然后再以组合的方式来调用这个对象。

虽然，在给的使用建议上是说将对象的实现部分和抽象部分进行剥离。其实，我感觉，在很多情况下都使用到了这一模式。而不单单是对实现和抽象部分的剥离上。因为桥接模式能够是一些对象的调用变得方便，故而在诸多的情况下都是可以进行使用的。

补充：软件开发 , C++ ,