共计 1081 个字符，预计需要花费 3 分钟才能阅读完成。

#ifndef BRIDGE_H
#define BRIDGE_H
#include <iostream>
using namespace std;

class CFlavouring
{
public:
    virtual void Add() = 0;};

class CSalt:public CFlavouring
{
public:
    void Add(){ cout<<"Add Salt."<<endl;};
};

class CSugar:public CFlavouring
{
public:
    void Add(){cout<<"Add sugar."<<endl;};
};

class CFood
{
public:
    CFood(CFlavouring* pFlav):m_pFlav(pFlav){}
    virtual void Make() = 0; 
protected:
    CFlavouring* m_pFlav;
};

class CBread:public CFood
{
public:
    CBread(CFlavouring* pFlav):CFood(pFlav){}
    void Make()
    {
        cout<<"Make Bread."<<endl;
        m_pFlav->Add();}
};

class CNoodles:CFood
{
public:
    CNoodles(CFlavouring* pFlav):CFood(pFlav){}
    void Make()
    {
        cout<<"Make Noodles."<<endl;
        m_pFlav->Add();}
};
#endif

#include "bridge.h"
#define SAFE_DELETE(p) if(p){delete (p); (p) = 0;}

int main(int argc, char* argv[])
{
    CFlavouring* pFlavSalt = new CSalt;
    CFood* pBread = new CBread(pFlavSalt);// 这里只做出了咸味面包
    pBread->Make();
    SAFE_DELETE(pBread);
    SAFE_DELETE(pFlavSalt);
    return 0;
}

共计 2441 个字符，预计需要花费 7 分钟才能阅读完成。

桥接模式
定义

将抽象部分与具体部分分离，使他们都可以独立的变化。
通过组合的方式建立两个雷之间的联系，而不是继承。

类型
结构型
使用场景

抽象和具体实现之间的增加更多的灵活性。
一个类存在两个（或多个）独立变化的维度，且者两个（或多个）维度都需要独立进行扩展。
不希望使用多层继承导致系统中类的个数剧增。

优点

分离抽象部分机器具体实现部分（使抽象和继承不再在同一个继承层次中，让抽象和实现可以在各自的维度中发展）
提高了系统的可扩展性
符合开闭原则
符合合成复用原则

难点
在使用桥接模式时难点就是需要正确的识别系统中两个独立变化的维度。
在写代码之前我们先假设一个场景，我们现在要实现一个银行的存款操作，存款的话就包括有活期和定期之分，然后存款也有不同的银行。我们就要用代码来模拟这个操作。我们说桥接模式的难点就在于抽象和实现进行分离。我们现在先用一个接口当做抽象层。把账户的相关操作放进这个接口里面。
public interface Account {
Account openAccount();
void showAccountType();

}
这里定义了两个方法，然后我们写一下银行的抽象类，一会我们要委托这个抽象类来执行具体的操作。
public abstract class Bank {
protected Account account;
public Bank(Account account){
this.account = account;
}
abstract Account openAccount();
}
我们这里定义了一个与接口相同名称的方法，为什么要这么做呢？我们一会再解答。这里有一个账户的属性，然后将账户对象注入进来，使用构造器的方式注入。我们再实现一下具体的银行类。我们来写一个农业银行 ABCBank 一个工商银行 ICBCBank（爱存不存银行）。这个两个银行继承 bank 抽象类。实现抽象方法。
//ABCBank
public class ABCBank extends Bank {
public ABCBank(Account account) {
super(account);
}

@Override
Account openAccount() {
System.out.println(“ 打开中国农业银行账号 ”);
account.openAccount(); // 这一行很关键，这是委托父类执行操作的代码
return account;
}
}
//ICBCBank
public class ICBCBank extends Bank {
public ICBCBank(Account account) {
super(account);
}

@Override
Account openAccount() {
System.out.println(“ 打开中国工商银行账号 ”);
account.openAccount();
return account;
}
}

这个实现类继承抽象类，在执行 openAccount 是直接调用父类的方法。这时候我们说一下为什么要让抽象类和接口一样的名称呢，其实这个不一样也是可以的，我们写成一样的只是想让他们表一样的操作，我们的 openAccount 方法重点是要调用 account 的 openAccount。
// DepositAccount
public class DepositAccount implements Account {
@Override
public Account openAccount() {
System.out.println(“ 打开定期账号 ”);
return new DepositAccount();
}

@Override
public void showAccountType() {
System.out.println(“ 这是一个定期账号 ”);
}
}
//SavingAccount
public class SavingAccount implements Account {
@Override
public Account openAccount() {
System.out.println(“ 打开活期账号 ”);
//…
return new SavingAccount();
}

@Override
public void showAccountType() {
System.out.println(“ 这是一个活期账号 ”);
}
}

这两个实现类实现了接口方法。我们最后看看测试类。
public class BridgeTest {
public static void main(String[] args) {
Bank icbcBank = new ICBCBank(new DepositAccount());
Account icbcAccount = icbcBank.openAccount();
icbcAccount.showAccountType();

Bank icbcBank2 = new ICBCBank(new SavingAccount());
Account icbcAccount2 = icbcBank2.openAccount();
icbcAccount2.showAccountType();

Bank abcBank = new ABCBank(new SavingAccount());
Account abcAccount = abcBank.openAccount();
abcAccount.showAccountType();
}
}

我们创建一个银行对象将农业银行赋值给他，同时将一个定期账户传入构造器，注入银行类中，然后银行类在执行 openAccount 方法调用的是 account 类的 openAccount 方法，这样的话我们就讲 account 和 bank 类组合到了一起。后面我们在扩展比如添加 bank 类时就和 account 类解耦了，再通过他们的排列组合就可以得到很多结果了。最后我们看一下运行结果。
打开中国工商银行账号
打开定期账号
这是一个定期账号
打开中国工商银行账号
打开活期账号
这是一个活期账号
打开中国农业银行账号
打开活期账号
这是一个活期账号