大话设计模式之建造者模式

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

比如同一种圆，可以有不同的半径（细节）

建造者模式又叫‘生成器模式’

如果我们使用了建造者模式，那么用户就只需要指定需要建造的类型就可以得到它们，而具体的建造过程和细节就不需要知道了

 

//抽象的建造人的类
abstractclass PersonBuilder
{
    public abstract void BuildHead();
    public abstract void BuildBody();
    public abstract void BuildArmLeft();
    public abstract void BuildArmRight();
    public abstract void BuildLegLeft();
    public abstract void BuildLegRight();
};
 
//人物A的模型细节
class ThinPersonBuilder :PersonBuilder
{
    public void BuildHead()         //具体各部位大小
    {
        // concret data
    }
    public void BuildBody()
    {
        //..
    }
    public void BuildArmLeft()
    {
        //..
    }
    public void BuildArmRight()
    {
        //..
    }
    public void BuildLegLeft()
    {
        //..
    }
    public void BuildLegRight()
    {
        //..
    }
};
 
//人物B的模型细节
class FatPersonBuilder :PersonBuilder
{
    public void BuildHead()
    {
        // concret data
    }
    public void BuildBody()
    {
        //..
    }
    public void BuildArmLeft()
    {
        //..
    }
    public void BuildArmRight()
    {
        //..
    }
    public void BuildLegLeft()
    {
        //..
    }
    public void BuildLegRight()
    {
        //..
    }
};
 
class PersonDirector
{
    private PersonBuilder p;
 
    public PersonDirector(PersonBuilder p)
    {
        this.p = p;
    }
 
    public void CreatePerson()          //每个人物必不可少的部分
    {
        p.BuildHead();
        p.BuildBody();
        p.BuildArmLeft();
        p.BuildArmRight();
        p.BuildLegLeft();
        p.BuildLegRight();
    }
};
 
//若是以后需要建造 HighPerson 或是 ShortPerson的话也只是要写两个相关的类，不用在意具体建造过程
//这样做其实是因为我们可能在建造同类型事物的时候可能会遗漏某部分，所以将其总结在Director中，以后只需要在意细节

 

 

建造者模式解析：

        

 

这里的Builder就是为创建一个product对象的各个部件指定的抽象接口，但是在Builder中我们不提供组装成最终product的方法，该方法是放在Director类中的

而product即为我们最终要产生的产品

ConcretBuilder即为抽象接口的具体实现

Director类即为我们指挥Builder的具体实现的各个部件如何组装成最终的product

 

何时使用该模式？

         创建者模式主要用于创建一些复杂的对象，这些对象内部构件间的建造顺序通常是稳定的，但对象内部的构建常面临着复杂的变化

 

基础代码：

//产品类，由多个部件组成
class Product
{
    IList<string> parts = newIList<string>();
 
    public void Add(string part)
    {
        parts.Add(part);
    }
 
    public void show()
    {
        Console.WriteLine("\n产品---创建 ---");
        foreach(string part in parts)
        {
            Console.WriteLine(part);
        }
    }
};
 
//builder类，抽象建造者类，确定产品由两个部件组成，并声明一个得到产品建造后结果的方法 GetResult
abstractclass Builder
{
    public abstract void BuildPartA();
    public abstract void BuildPartB();
    public abstract Product GetResult();
};
 
class ConcretBuilder1 :Builder          //每个具体类都是对部件的具体实现，并没有什么组装过程
{
    private Product p = new Product();
 
    public override void BuildPartA()
    {
        p.Add("部件A");                             //A和B两个部件
    }
 
    public override void BuildPartB()
    {
        p.Add("部件B");
    }
 
    public override Product GetResult()
    {
        return product;
    }
};
 
class ConcretBuilder2 :Builder
{
    private Product p = new Product();
 
    public override void BuildPartA()
    {
        p.Add("部件X");                             //X和Y两个部件
    }
 
    public override void BuildPartB()
    {
        p.Add("部件Y");
    }
 
    public override Product GetResult()
    {
        return product;
    }
};
 
//指挥者类
class Director
{
    public void Construct(Builder b)
    {
        b.BuildPartA();             //指挥建造过程
        b.BuildPartB();
    }
}
 
//客户端， 客户不需要知道具体的建造过程
void main()
{
    Director d = new Director();
    Builder b1 = new ConcretBuilder1();
    Builder b2 = new ConcretBuilder2();
 
    d.Construct(b1);
    Product p1 = b1.GetResult();
    p1.show();
 
    d.Construct(b2);
    Product p2 = b2.GetResult();
    p2.show();
}

 

所以说建造者模式是在当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配方式时候使用的模式