系列文章

[Head First设计模式]山西面馆中的设计模式——装饰者模式

[Head First设计模式]山西面馆中的设计模式——观察者模式

引言

将学习融入生活中，是件很happy的事情，不会感觉到累。一个感觉：很好玩！挺开心的……

为什么会出现建造者模式？

在软件系统中，有时面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成。

这个复杂的对象的各个部分经常面临剧烈变化，但是将它们组合在一起的算法却相对稳定。

比如：建一所房子，建房子的过程基本不变（算法：画图-地基-建造），但是门窗之类的组建确是易变的。

怎么应对这种变化？

如何提供一种“封装机制“来隔离出”复杂对象的各个部分“的变化，从而保持系统中的”稳定构建算法“不随需求改变而改变，这就是建造者模式。

使用建造者模式的目的？

将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

建造者模式定义

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

一步步创建复杂的对象，它允许用户只通过制定复杂对象的类型和内容就可以创建它们，用户不知道内部的具体构建细节。

建造者模式类图

建造者模式参与者

抽象建造者（Builder）

为创建一个产品角色对象的各个部件指定抽象接口。

具体建造者（Conctrete Builder）

实现抽象建造者接口，构造和装配产品的各个部件。

定义并明确它所创建的表示。

提供一个返回这个产品的接口。

指挥者（Director）

构建一个使用抽象建造者接口的对象。

产品角色（Product）

被构建的复杂对象，具体建造者创建该产品的内部表示并定义它的装配过程。

包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

 实例分析

场景：lz现在在前台点一份大份量的鸡蛋面，据吃货所知，山西面馆中，对鸡蛋面提供三种的做法，1.普通分量的 2.加2元面的大份量的 3.加一个鸡蛋的营养餐。

分析：

抽象建造者：家传制面秘方（算法），所有鸡蛋面的制作过程均要遵循本秘方，否则是砸自己的招牌啊。

具体的建造者：小康师傅（水平有限，面的多少把握不够，徒弟级别），康师傅（多年砍面技术溶于一身，造就了神般的人物，要砍多少面就多少，不多不少正好），康氏（女人，总比男人更懂得营养，营养师级别人物）

指挥者：收银员，根据order指挥这份面如何来做（是否加量，是否加鸡蛋）。

产品角色：鸡蛋面。

代码实现：

 建造者 指定不变的创建过程（算法）

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Threading.Tasks;
 6 
 7 namespace Wolfy.建造者模式
 8 {
 9     /// <summary>
10     /// 为创建产品指定相对稳定的算法（步骤）
11     /// </summary>
12     public abstract class Builder
13     {
14         /// <summary>
15         /// 水温
16         /// </summary>
17         public abstract void WaterTemperature();
18         /// <summary>
19         /// 削多少下面
20         /// </summary>
21         public abstract void CutTimesWheatflour();
22         /// <summary>
23         /// 添加西红柿
24         /// </summary>
25         public abstract void AddTomattos();
26         /// <summary>
27         /// 添加鸡蛋
28         /// </summary>
29         public abstract void AddEggs();
30         /// <summary>
31         /// 搅拌
32         /// </summary>
33         public abstract void Stir();
34         /// <summary>
35         /// 返回
36         /// </summary>
37         public abstract Food BuildFood();
38     }
39 }

View Code

具体建造者

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Threading.Tasks;
 6 
 7 namespace Wolfy.建造者模式
 8 {
 9     /// <summary>
10     /// 建造者模式中的具体建造者 小康师傅类 负责普通鸡蛋面的生产
11     /// </summary>
12     public class LittleMasterKang : Builder
13     {
14         Food normalFood = new Food();
15         public override void WaterTemperature()
16         {
17             Console.WriteLine("小康师傅：嗯，水温有100℃了，可以下面了");
18             normalFood.DicFood.Add("汤",0);
19         }
20 
21         public override void CutTimesWheatflour()
22         {
23             Console.WriteLine("小康师傅：咔咔.....嗯，够了");
24             normalFood.DicFood.Add("面",5f);
25         }
26 
27         public override void AddTomattos()
28         {
29             Console.WriteLine("小康师傅：切两个西红柿，咔咔.....放入锅中");
30             normalFood.DicFood.Add("西红柿",2f);
31         }
32 
33         public override void AddEggs()
34         {
35             Console.WriteLine("小康师傅：鸡蛋");
36             normalFood.DicFood.Add("鸡蛋",3f);
37         }
38 
39         public override void Stir()
40         {
41             Console.WriteLine("小康师傅：一圈，二圈，三圈....{0}圈,嗯,够了", 50); 
42         }
43         /// <summary>
44         /// 返回食物
45         /// </summary>
46         public override Food BuildFood()
47         {
48             return normalFood;
49         }
50     }
51 }

LittleMasterKang

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Threading.Tasks;
 6 
 7 namespace Wolfy.建造者模式
 8 {
 9     /// <summary>
10     /// 具体建造者 大师级的康师傅类 用来生产大份量的套餐 
11     /// </summary>
12     public class MasterKang : Builder
13     {
14         Food normalFood = new Food();
15         public override void WaterTemperature()
16         {
17             Console.WriteLine("小康师傅：嗯，水温有100℃了，可以下面了");
18             normalFood.DicFood.Add("汤", 0);
19         }
20 
21         public override void CutTimesWheatflour()
22         {
23             Console.WriteLine("康师傅：咔咔.....嗯，够了");
24             normalFood.DicFood.Add("面(2￥)", 7f);
25         }
26 
27         public override void AddTomattos()
28         {
29             Console.WriteLine("康师傅：切两个西红柿，咔咔.....放入锅中");
30             normalFood.DicFood.Add("西红柿", 2f);
31         }
32 
33         public override void AddEggs()
34         {
35             Console.WriteLine("康师傅：鸡蛋");
36             normalFood.DicFood.Add("鸡蛋", 3f);
37         }
38 
39         public override void Stir()
40         {
41             Console.WriteLine("康师傅：一圈，二圈，三圈....{0}圈,嗯,够了", 60);
42         }
43         /// <summary>
44         /// 返回食物
45         /// </summary>
46         public override Food BuildFood()
47         {
48             return normalFood;
49         }
50     }
51 }

MasterKang

指挥者

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Threading.Tasks;
 6 
 7 namespace Wolfy.建造者模式
 8 {
 9     /// <summary>
10     /// 收银员类 即建造者模式中的指挥者 根据订单指挥 到底做什么样的面
11     /// </summary>
12     public class Cashier
13     {
14         public void BuidFood(Builder builder)
15         {
16             builder.WaterTemperature();
17             builder.CutTimesWheatflour();
18             builder.AddTomattos();
19             builder.AddEggs();
20             builder.Stir();
21         }
22     }
23 }

Cashier

产品Food

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Threading.Tasks;
 6 
 7 namespace Wolfy.建造者模式
 8 {
 9     /// <summary>
10     /// 产品类
11     /// </summary>
12     public class Food
13     {
14         Dictionary<string, double> dicFood;
15 
16         public Dictionary<string, double> DicFood
17         {
18             get { return dicFood; }
19             set { dicFood = value; }
20         }
21         public Food()
22         {
23             dicFood = new Dictionary<string, double>();
24         }
25         private double price;
26         private string foodName;
27         public void ShowFood()
28         {
29             foreach (KeyValuePair<string, double> item in dicFood)
30             {
31                 foodName += item.Key + ",";
32                 price += item.Value;
33             }
34             string[] food = foodName.TrimEnd(',').Split(',');
35             //为了显示 按正常的顺序显示
36             foodName = food[2] + food[3] + food[0] + food[1];
37             Console.WriteLine(foodName + "\t" + price + "￥");
38         }
39     }
40 }

Food

控制台代码

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Threading.Tasks;
 6 
 7 namespace Wolfy.建造者模式
 8 {
 9     class Program
10     {
11         static void Main(string[] args)
12         {
13             //创建指挥者 
14             Cashier director = new Cashier();
15             //创建普通鸡蛋面的制造者 小康师傅
16             LittleMasterKang kang = new LittleMasterKang();
17             director.BuidFood(kang);
18             Food food = kang.BuildFood();
19             food.ShowFood();
20             Console.WriteLine();
21             //创建大份量鸡蛋面建造者 康师傅
22             MasterKang k = new MasterKang();
23             director.BuidFood(k);
24             Food f = k.BuildFood();
25             f.ShowFood();
26             Console.Read();
27         }
28     }
29 }

结果

总结

建造者模式类似于工厂模式，但又有所不同，建造者模式最主要的功能是基本方法的调用顺序的安排，这些基本方法已经实现，而工厂方法则重点是创建，组装顺序则不关心。
使用场景

一是产品类非常复杂，或者产品类中调用顺序不同会产生不同的效果。

二是在对象创建过程中会使用到系统中的一些其他对象这些对象在产品对象的创建过程中不容易得到

参考

http://www.cnblogs.com/ywqu/archive/2010/01/11/1643753.html