桥接模式(Bridge Pattern)

    如果有一个N品牌的手机，它有个小游戏，我要玩游戏，程序应该如何写？

    客户端

    2. game.run();

    现在又有一个M品牌的手机，也是小游戏，客户端也可以调用，如何做？

    1. class HandSetGame
    2. {
    3.     public virtual void Run()
    4.     {
    5.     }
    6. }

    M品牌手机游戏和N品牌手机游戏

    1. class HandSetMGame : HandSetGanme
    2. {
    3.     public override void Run()
    4.     {
    5.         Console.WriteLine("运行M品牌手机游戏");
    6.     }
    7. }
    9. class HandSetNGame : HandSetGanme
    10. {
    11.     public override void Run()
    12.     {
    13.         Console.WriteLine("运行N品牌手机游戏");
    14.     }
    15. }

    然后，由于手机都需要通讯录功能，于是N品牌和M品牌都增加了通讯录的增删该查功能，如何处理？

    1. //手机品牌
    2. class HandSetBrand
    3. {
    4.     public virtual void run()
    5.     {
    6.     }
    7. }

    下属的各自通讯录类和游戏类

    1. //手机品牌M的游戏
    2. class HandSetBrandMGame:HandSetBrandM
    3. {
    4.     public override void Run()
    5.     {
    6.         Console.WriteLine("运行M品牌手机游戏");
    7.     }
    8. }
    10. //手机品牌N的游戏
    11. class HandSetBrandMGame:HandSetBrandM
    12. {
    13.     public override void Run()
    14.     {
    15.         Console.WriteLine("运行N品牌手机游戏");
    16.     }
    17. }
    19. //手机品牌M的通讯录
    20. class HandSetBrandMAddressList:HandSetBrandM
    21. {
    22.     {
    24.     }
    25. }
    27. //手机品牌N的
    28. class HandSetBrandMAddressList:HandSetBrandM
    29. {
    30.     public override void Run()
    31.     {
    32.         Console.WriteLine("运行N品牌手机通讯录");
    33.     }
    34. }

    客户端调用代码

    1. static void Main(strring[] args)
    2. {
    3.     HandSetBrand ab;
    5.     ab = new HandSetBrandMAddressList();
    6.     ab.Run();
    8.     ab = new HandSetBrandNAddressList();
    9.     ab.Run();
    11.     ab = new HandSetBrandMGame();
    12.     ab.Run();
    14.     ab = new HandSetBrandNGame();
    15.     ab.Run();
    17.     Console.Read();
    18. }

    如果我现在需要每个品牌都增加一个MP3音乐功能，如何做？还增加子类？

    合成(Composition)／聚合(Aggregation)复用原则,尽量使用合成／聚合，尽量不要使用类继承。

    聚合表示一种弱的’拥有’关系，体现的是A对象可以包含B对象，但是B对象不是A对象的一部分。合成则是一种强的’拥有’关系，体现了严格的部分和整体的关系，部分和整体的生命周期一样。

    比如说 大雁有翅膀，大雁和翅膀是部分和整体的关系，并且它们生命周期是一样的，于是它们就是合成关系。而大雁是群居动物，所以每只大雁都属于一个雁群，一个雁群可以有很多大雁，所以大雁和雁群是聚合关系。

    优先使用对象的合成／聚合将有助于你保持每个类被封装，并被集中在单个任务上。这样类和类继承层次会保持较小规模，并且不太可能增长为不可控制的庞然大物。

    像’游戏’，’通讯录’，’MP3音乐’，如果我们可以让其分离与手机的耦合，那么可以大大减少面对新需求改动过大的不合理情况。

    松耦合的程序

    1. //手机软件
    2. abstract class HandsetSoft
    3. {
    4.     public abstract void Run();
    5. }

    游戏，通讯录等具体类

    1. //手机游戏
    2. class HandsetGame : HandSetSoft
    3. {
    4.     public override void Run()
    5.     {
    6.         Console.WriteLine("运行手机游戏");
    7.     }
    8. }
    10. //手机通讯录
    11. class HandsetAddressList : HandSetSoft
    12. {
    13.     public override void Run()
    14.     {
    15.         Console.WriteLine("运行手机通讯录");
    16.     }
    17. }

    品牌N品牌M具体类

    2. {
    3.     public override void Run()
    4.     {
    5.         soft.Run();
    6.     }
    7. }
    9. //手机品牌M
    10. class HandSetBrandM: HandBrand
    11. {
    12.     public override void Run()
    13.     {
    14.         soft.Run();
    15.     }
    16. }
    1. static void Mian(string[] args)
    2. {
    3.     HandSetBrand ab;
    4.     ab = new HandSetBrandN();
    6.     ab.setHandSetSoft(new HandSetGame());
    7.     ab.run();
    9.     ab.setHandSetSoft(new HandSetAddressList());
    10.     ab.run();
    12.     ab = new HandSetBrandM();
    14.     ab.setHandSetSoft(new HandSetGame());
    15.     ab.run();
    17.     ab.setHandSetSoft(new HandSetAddressList());
    18.     ab.run();
    20.     Console.Read();
    21. }

    现在我们要再加个功能 比如说MP3功能，只要增加这个类就好了，不会影响其它任何类。

    1. //手机MP3播放
    2. class HandsetMP3 : HandSetSoft
    3. {
    4.     public override void Run()
    5.     {
    6.         Console.WriteLine("运行手机MP3");
    7.     }
    8. }

    如果要增加S品牌，只需要增加一个品牌子类就可以了。

    1. //手机品牌S
    2. class HandSetBrand: HandSetBrand
    3. {
    4.     public override void Run()
    5.     {
    6.         soft.Run();
    7.     }
    8. }

    桥接模式:将抽象部分与它的实现部分分离，使它们都可以独立地变化。

    什么叫抽象与它的实现分离，这并不是说，让抽象与其派生类分离，因为这没有任何意义。实现指的是抽象类和它的派生类用来实现自己的对象。

    桥接模式基本代码

    桥接模式 - 图1

    桥接模式把两个角色之间的继承关系改为聚合关系，从而使二者可以各自独立的变化。把原来在基类的实现化细节抽象出来，再构造到一个实现化的结构中，然后把原来的基类改造成一个抽象化的等级结构，这样就实现了系统在多个维度上的独立变化。