设计模式之四建造者(Builder)模式

一.概述
在软件系统 中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变 化，但是将它们组合在一起的算法确相对稳定。如何应对这种变化？如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化，从而保持系统中的“稳定 构建算法”不随着需求改变而改变？这就是要说的建造者模式
二.意图
将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
三.分析
对读者而言，“意图”相对于“概述”更难于理解，“意图”用相当精炼简介的语言来表述模式的；那么我们可以从概述入手，逐句理解模式的各个方面：
1.一个高级对象，它由几部分子对象组成
2.各个子对象组合在一起，就形成了最终的复杂对象，并且，各自对象组成复杂对象的算法是稳定的
3.各个子对象经常发生剧烈的变化（变化点）
4.隔离变化点，也即：隔离各个子对象的变化
四.模型图

五.示例
先看示例，之后我们根据示例来理解此图的含义
我们日常用的电脑主机箱，可以大致的分为CPU,内存，主板，硬盘等几个重要部分,这些部分经常由于型号的不同而各子发生变化，但是把它们组装成机箱的工序却是一样的
由于这里创建各个子部分时，是经常变化，那么根据隔离变化点的原则，我们应该进行抽象，我们大致可以抽象出下列几个抽象方法：
a.BuilderCpu
b.BuilderMem
c.BuilderMainboard
d.BuilderHD
那么我们的抽象类该是这样的：

public abstract class Builder
    {
       public abstract void BuilderCpu();
       public abstract void BuilderMem();
       public abstract void BuilderMainboard();
       public abstract void BuilderHD();
       public abstract Computer GetComputer();
    }
   public abstract class Computer
   { 
        
   }

各个型号的电脑组成应该是Builder类的子类，以HP和IBM型号为例：

 public class IBM : Computer
    { 
    
    }
   public  class IBMBuilder:Builder
    {
       public override void BuilderCpu()
       {
           
       }
       public override void BuilderMem()
       {
           
       }
       public override void BuilderMainboard()
       {
           
       }
       public override void BuilderHD()
       {
           
       }
       public override Computer GetComputer()
       {

       }
    }

 public class HP : Computer
    { 
    
    }
    public class HPBuilder:Builder
    {
        public override void BuilderCpu()
        {
            
        }
        public override void BuilderMainboard()
        {
            
        }
        public override void BuilderMem()
        {
            
        }
        public override void BuilderHD()
        {
            
        }
        public override Computer GetComputer()
        {
            
        }
    }

由于组装算法是稳定的，所以我们把它写成一个类，也即上图中的Director。

public  class Director
    {
       public void Constructor(Builder builder)
       {
           builder.BuilderCpu();
           builder.BuilderMem();
           builder.BuilderMainboard();
           builder.BuilderHD();
       }
    }

客户程序：

 static void Main(string[] args)
        {
            Director dir = new Director();
            Builder builder = (Builder)(new IBMBuilder());
            dir.Constructor(builder);
            Computer computer=(Computer)builder.GetComputer();
        }

六.代码分析
抽象类Builder和Computer 是代码中最稳定的部分，一个是产品的抽象 一个是建造者的抽象
HPBuilder和IBMBuilder是Builder的具体实现，类IBM和HP是COMPUTER 的具体实现
Directory也是不变的部分，担任指导者的角色
在客户程序中，先实例化一个指导者对象，而后根据具体的建造者类型实例化Builder对象，并且将此对象作为指导者对象方法Constructor的参数，此方法承担各个子对象的组装工作，最后调用GeComputer方法获得最终的复杂对象
调用过程如图：