GoF《设计模式》中说到：将对象组合成树形结构以表示“部分-整体”的层次结构。Composite模式使得客户对单个对象和组合对象的使用具有一致性。

       Composite组合模式结构如下：

       说道这，我觉得有一个编程中常见的场景，就是对于树的实现，很符合这个模式。下面我就用这个例子作一下。

       首先，我们先分析对于一棵树所包含的部分，树干、树枝、树叶，其中树干可以看成一个树枝（就是粗了点）。那么我们就应该有两种类实现Leaf（树叶）和Limb（树枝）。对于叶子节点和枝节点的不同在于枝节点有子树，而叶子节点没有子树。为了使单个对象和组合对象的使用具有一致性，我可以将叶子节点想象成没有子树的枝节点。这样我就可以得到一个抽象类，代码如下：

       public abstract class AbstractClass

    {

        public string name;

        public ArrayList list;

        public abstract void Add(AbstractClass item);       //增加一个子节点

        public abstract void Remove(AbstractClass item);    //去掉一个子节点

        public abstract string Print();                     //打印当前节点

    }

       然后，我在对叶子节点和枝节点作不同的实现：

       枝节点：

       public class Limb:AbstractClass

    {

        public Limb()

        {

            list = new ArrayList();

        }

        public override void Add(AbstractClass item)

        {

            list.Add(item);

        }

        public override void Remove(AbstractClass item)

        {

            if(list.Contains(item))

                list.Remove(item);

        }

        public override string Print()

        {

            Console.Write(name + "\n");

            if(list.Count != 0)

            {

                for(int i = 0;i<list.Count;i++)

                {

                    Console.Write("(Parent is " + name + ")");

                    ((AbstractClass)list[i]).Print();

                }

            }

            return name;

        }

    }

    叶子节点：

    public class Leaf:AbstractClass

    {

        public Leaf()

        {

            list = null;

        }

        public override void Add(AbstractClass item)

        {

        }

        public override void Remove(AbstractClass item)

        {

        }

        public override string Print()

        {

            Console.Write(name + ",");

            return this.name;

        }

    }

    对于叶子节点来说，不需要子节点，当然也就不需要添加和删除子节点的方法。

    好，接下来，我们可以在客户程序中组建一棵树，来测试一下：

        static void Main(string[] args)

        {

            AbstractClass Tree = new Limb();

            GetTree(Tree);

            PrintTree(Tree);

            Console.Read();

        }

        public static void GetTree(AbstractClass Tree)

        {

            Tree.name = "1";

            AbstractClass leaf2 = new Leaf();

            leaf2.name = "2";

            Tree.Add(leaf2);

            AbstractClass limb3 = new Limb();

            limb3.name = "3";

            Tree.Add(limb3);

            AbstractClass leaf4 = new Leaf();

            leaf4.name = "4";

            limb3.Add(leaf4);

            AbstractClass leaf5 = new Leaf();

            leaf5.name = "5";

            limb3.Add(leaf5);

        }

        public static void PrintTree(AbstractClass Tree)

        {

            Tree.Print();

        }

    输出结果如下：

1

(Parent is 1)2,(Parent is 1)3

(Parent is 3)4,(Parent is 3)5,

在组织这个树时，的确能感觉到GoF《设计模式》中的那句话：单个对象和组合对象的使用具有一致性。当然也的确感觉到一点矛盾：对于叶子节点来说，不需要ArrayList和Add（）Remove（）应该不继承才对，当然如果在代码执行性能可以达到要求的情况下，简化一下编码实现复杂度也是挺好的一件事。

最后在来说说Composite组合模式的几个要点：

       1、Composite模式采用树形结构来实现普遍存在的对象容器，从而将“一对多”的关系转化为“一对一”的关系，使得客户代码可以一致的处理对象和对象容器，无需关心处理的是单个对象，还是组合的对象容器。

2、将“客户代码与复杂的对象容器结构”解耦是Composite模式的核心思想，解耦之后，客户代码将与纯粹的对象接口——而非对象容器的复杂内部实现结构——发生依赖关系，从而更能“应对变化”。

3、Composite模式中，是将“Add和Remove的和对象容器相关的方法”定义在“表示抽象对象的Component类”中，还是将其定义在“表示对象容器的Composite类”中，是一个关乎“透明性”和“安全性”的两难问题，需要仔细权衡结构，这又是必须付出的代价。

4、Composite模式在具体实现中，可以让父对象中的字对象反向追溯：如果父对象有频繁的遍历需求，可使用缓存技巧来改善效率

       《设计模式》中说到将抽象部分与实现部分分离，使他们可以独立的变化。

       举个例子更清楚些，好像我们平时玩的游戏中有PS版的，但是不是大家都有PS。这时我们等一段时间，一般会出PC版的或其他版本。由于支持游戏的平台不一样，但是如果我们编写的游戏程序为了适应另一种平台就要全部重新编写的话岂不是很麻烦。再加上游戏本身的变动，一句众人皆知的话：“死定了”。

       现在我们来看看Bridge桥接模式，看看它是如何解决类似问题的，首先我们看看Bridge模式的结构。

       实际上，我们要做到的是把变化的部分提出，对其抽象，使变化独立。那我们如何做呢？通过组合的方式将变化独立出去。将一个事物中的多个纬度变化分离。

       下面举一个场景来理解一下，还是用汽车举例，我现在要一辆车（BMW或BORA）在路（WaterRoad或Cement）上跑。现在有两个纬度的变化点：汽车和路。也就是上图中的AbstractChangePoint1和AbstractChangePoint2。AbstractChangePoint1中包含有AbstractChangePoint2对象成员。。代码实现如下：

       abstract class AbstractCar

    {

        public AbstractRoad road;

        public AbstractCar(AbstractRoad road)

        {

            this.road = road;

        }

        public abstract string Run();

        public abstract string Stop();

    }

    abstract class AbstractRoad

    {

        public abstract string GetRoadType();

}

以汽车为变化中心，用组装的方式将两个变化点结合起来。使路的变化和汽车隔离。下面来编写路的实现。

class WaterRoad:AbstractRoad

    {

        public override string GetRoadType()

        {

            return "It is WaterRoad";

        }

 }

class CementRoad:AbstractRoad

    {

        public override string GetRoadType()

        {

            return "It is Cement";

        }

}

然后再来编写汽车的实现

class BMWCar:AbstractCar

    {

        public BMWCar(AbstractRoad road)

            : base(road)

        {

        }

        public override string Run()

        {

            return "BMW is running";

        }

        public override string Stop()

        {

            return "BMW is stopped";

        }

 }

class BROACar:AbstractCar

    {

        public BROACar(AbstractRoad road)

            : base(road)

        {

        }

        public override string Run()

        {

            return "BROA is running";

        }

        public override string Stop()

        {

            return "BROA is stopped";

        }

  }

然后我们在客户代码中调用这些类，首先，我想要这个场景是BMW在WaterRoad上跑，客户端代码如下：

static void Main(string[] args)

        {

            AbstractCar car = new BMWCar(new WaterRoad());

            Console.WriteLine(car.road.GetRoadType());

            Console.WriteLine(car.Run());

            Console.WriteLine(car.Stop());

            Console.Read();

        }

实现结果如下：

It is WaterRoad

BMW is running

BMW is stopped

如果我现在要一辆BORA在Cement上跑，我们只要稍微修改一下car的实例化就可以，代码如下：

static void Main(string[] args)

        {

            AbstractCar car = new BROACar(new CementRoad());

            Console.WriteLine(car.road.GetRoadType());

            Console.WriteLine(car.Run());

            Console.WriteLine(car.Stop());

            Console.Read();

     }

实现结果如下：

It is Cement

BROA is running

BROA is stopped

       最后我们再来说说Bridge模式的要点：

       1、Bridge模式使用“对象间的组合关系”解耦了抽象和实现之间固有的绑定关系，使得抽象和实现可以沿着各自的纬度来变化。

2、所谓抽象和实现沿着各自纬度的变化，即“子类化”它们，得到各个子类之后，便可以任意组合它们。

3、Bridge模式有时候类似于多继承方案，但是多继承方案往往违背单一职责原则（即一个类只有一个变化的原因），复用性比较差。Bridge模式是比多继承方案更好的解决方法。

4、Bridge模式的应用一般在“两个非常强的变化纬度”，有时候即使有两个变化的纬度，但是某个方向的变化纬度并不剧烈——换言之两个变化不会导致纵横交错的结果，并不一定要使用Bridge模式。

       这是解决一个复杂对象的创建工作，现在变化的部分和相对稳定的部分已经明确，我们要做的是隔离变化，如何将子对象和算法隔离是要解决的问题。

       《设计模式》中说道：将一个复杂对象的构建与其表示向分离，使得同样的构建过程可以创建不同的表示。

       我们现在定义一个场景：还是选择汽车，BMW和BORA。试想一下，如果我们用较为普通的写法可以写成如下代码：

public static void Main()

        {

            Car car = new Car();

            Console.Write("Wheel:" + car._wheel + "\n");

            Console.Write("OilBox:" + car._oilBox + "\n");

            Console.Write("Body:" + car._body + "\n");

            Console.Read();

        }

        public class Car

        {

            public string _wheel = “BMWWheel”;

            public string _oilbox = “BMWOilBox”;

            public string _body = “BMWBody”;

}

当我们不确定或因需求变化而改变对汽车品牌的选择时，我们也许会频繁的更改Car类中的实现。

现在我们用Manager来管理汽车的构建。当然是构建一个抽象的类对象（对象如下图的builder，抽象类为AbstractBuilder）,对于BMW和BORA的构建类型继承AbstractBuilder类

首先我们先来编写AbstractBuilder抽象类的实现，代码如下：

public abstract class AbstractBuilder

    {

        public string _wheel;

        public string _oilBox;

        public string _body;

        public abstract void BuildWheel();

        public abstract void BuildOilBox();

        public abstract void BuildBody();

        public abstract Car GetCar();  

    }

    public abstract class Car

    {

    }

然后我们再来实现BMW和BORA的构建，也就是Builder模式中频繁变化的部分，他们都要继承AbstractBuilder

BMW：

public class BMWBuilder:AbstractBuilder

    {

        public BMWBuilder()

        {

            //

            // TODO: 在此处添加构造函数逻辑

            //

        }

        public override void BuildWheel()

        {

            _wheel = "BMWWheel";

        }

        public override void BuildOilBox()

        {

            _oilBox = "BMWOilBox";

        }

        public override void BuildBody()

        {

            _body = "BMWBody";

        }

        public override Car GetCar()

        {

            return new BMWCar();

        }

    }

    public class BMWCar:Car

    {}

BORA：

public class BORABuilder:AbstractBuilder

    {

        public BORABuilder()

        {

            //

            // TODO: 在此处添加构造函数逻辑

            //

        }

        public override void BuildWheel()

        {

            _wheel = "BORAWheel";

        }

        public override void BuildOilBox()

        {

            _oilBox = "BORAOilBox";

        }

        public override void BuildBody()

        {

            _body = "BORABody";

        }

        public override Car GetCar()

        {

            return new BORACar();

        }

    }

    public class BORACar:Car

    {}

现在我们使用一种Manager方法来管理汽车的构建，这也就是Builder模式中提到的相对稳定的算法，我用一个类来实现：

private class CarManager

        {

            public BuilderClass.Car CreateCar(BuilderClass.AbstractBuilder builder)

            {

                builder.BuildBody();

                builder.BuildOilBox();

                builder.BuildWheel();

                Console.Write("Wheel:" + builder._wheel + "\n");

                Console.Write("OilBox:" + builder._oilBox + "\n");

                Console.Write("Body:" + builder._body + "\n");

                Console.Read();

                return builder.GetCar();

            }

        }

现在我们可以在客户程序中调用这个Manager来构建Car：

public static void Main()

        {

            CarManager manager = new CarManager();

            BuilderClass.Car car =

manager.CreateCar(new BuilderClass.BORABuilder());

        }

结果如下：

Wheel:BORAWheel

OilBox:BORAOilBox

Body:BORABody

如果我们现在要换成BMW，我们只要在Main（）函数中改变manager.CreateCar中的参数就可以：

public static void Main()

        {

            CarManager manager = new CarManager();

            BuilderClass.Car car =  

manager.CreateCar(new BuilderClass.BMWBuilder());

        }

结果如下：

Wheel:BMWWheel

OilBox:BMWOilBox

Body:BMWBody

这样，经过简单的修改可以实现对不同Car的构建。如果我们还有其他汽车的实现只要将他的类继承AbstractBuilder，然后在Main（）中修改就可以。说道这里，我想起了在第一篇中提到的设计模式中的“开---闭原则”，这个方式是很符合这个原则的，对代码进行了扩展，以减少了代码修改量。而且我们还有很多方法可以利用，如：WebConfig中的appSettings来动态的配置，从数据库中读取，或利用依赖方式动态生成。

现在我们再来看看Builder模式的几个要点：

Builder模式主要用于构建一个复杂的对象，但这个对象构建的算法是稳定的，对象中的各个部分经常变化。Builder模式主要在于应对复杂对象各个部分的频繁需求变动。但是难以应对算法的需求变动。这点一定要注意，如果用错了，会带来很多不必要的麻烦。

课程中还提到了.Net中的Builder模式的应用。如：Page类中的OnInit（）等方法的实现。我们在写一个Web页面的时候。他的codebehind代码都是继承System.Web.UI.Page基类的。OnInit（）函数是可以重写的

 abstract class AbstractWheel
 {
  public AbstractWheel()
  {
   //Console.Write("Create a AbstractProduct");
  }
 }

 abstract class AbstractOilBox
 {
  public AbstractOilBox()
  {}
 }

 class BMWWheel:AbstractWheel
 {
  public BMWWheel()
  {
   Console.Write("Create a BMWwheel");
  }
 }

 class BMWOilBox:AbstractOilBox
 {
  public BMWOilBox()
  {
   Console.Write("Create a BMWOilBox");
  }
 }
 
     然后，我们在建立一个生产这些零件的工厂，它继承自一个抽象工厂

 //抽象工厂
 abstract class AbstractFactory
 {
  abstract public AbstractWheel CreatWheel();
  abstract public AbstractOilBox CreatOilBox();
 }

 class BMWFactory:AbstractFactory
 {
  public override AbstractWheel CreatWheel()
  {
   return new BMWWheel();
  }

  public override AbstractOilBox CreatOilBox()
  {
     return new BMWOilBox();
  }

 }

     现在我们在Main函数中调用它们：
 static void Main(string[] args)
  {
   AbstractFactory factory = null;
   factory = new BMWFactory();
   factory.CreatWheel();
   Console.Write("\n");
   factory.CreatOilBox();
   Console.Write("\n");
   Console.Read();
  }
     显示结果：
          Create a BMWwheel
          Create a BMWOilBox

     现在我们想不用BMW的零件，用BORA的零件了，先写一些BORA零件的类：
 class BORAWheel:AbstractWheel
 {
  public BORAWheel()
  {
   Console.Write("Create a BORAWheel");
  }
 }

 class BORAOilBox:AbstractOilBox
 {
  public BORAOilBox()
  {
   Console.Write("Create a BORAOilBox");
  }
 }
     然后我们再创建BORA零件的工厂：
 class BORAFactory:AbstractFactory
 {
  public override AbstractWheel CreatWheel()
  {
   return new BORAWheel();
  }

  public override AbstractOilBox CreatOilBox()
  {
   return new BORAOilBox();
  }

 }
     再来看看如何在Main函数中修改使其调用BORA的零件；我们只要在将Main中的factory对象实例化为BORA的工厂BORAFactory就可以了：
 static void Main(string[] args)
  {
   AbstractFactory factory = null;
   factory = new BORAFactory();
   factory.CreatWheel();
   Console.Write("\n");
   factory.CreatOilBox();
   Console.Write("\n");
   Console.Read();
  }
 
     结果如下：
          Create a BORAWheel
          Create a BORAOilBox

 
     Abstract Factory模式的几个要点：
          1、如果没有应对“多系列对象构建”的需求变化，则没有必要使用Abstract Factory模式。
          2、“系列对象”指的是这项对象之间有相互依赖、或作用的关系。
          3、Abstract Factory模式主要在于应对“新系列”的需求变动。缺点是难以应对“新对象”的需求变动。这一点应该注意，就像前面说的，如果我们现在要在加入其他系列的类，代码的改动会很大。
          4、Abstract Factory模式经常和Factory Method模式共同组合来应对“对象创建”的需求变化。