一、定义
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
简单来说：建造者模式，将一个产品的内部表象与产品的生成过程分隔开，从而可以使一个建造过程生成具有不同的内部表象的产品对象。
如果我们使用建造者模式，那么用户就只需要指定需要建设的类型就可以得到他们，而具体建造的过程和细节就不需要知道
设计模式-建造者模式_建造者模式

Director:指挥者，是构建一个使用Builder接口的对象
Builder：是为创建一个Product对象的各个部件指定的抽象接口
ConcreteBuilder：具体建造者，实现Builder接口，构造和装配各个部件
Product：具体产品

二、特点

  1. 对象的构建与它的表示分离
  2. Director来指挥建造，ConcreteBuilder来建造
  3. 客户不知道具体的建造过程

三、优缺点
优点：

  1. 使得建造代码与表示代码分离
  2. 由于建造者隐藏了该产品是如何组装的，所以若需要改变一个产品的内部表示，子需要再定义一个具体的建造者就可以了

四、 什么时候使用
主要用于创建一些复杂的对象，这些对象内部构建间的建造顺序通常是稳定的，但对象内部的构建通常面临着复杂的变化。

五、实例
1.建造者模式
Product类

class Product
{
IList parts = new List();
public void Add(string part)//添加产品部件
{
parts.Add(part);
}

    public void Show()
    {
        Console.WriteLine("\n产品 创建----");
        foreach (string part in parts )//列举所有产品部件
        {
            Console.WriteLine("part");
        }
    }
}

Builder类
//Builder类确定产品有两个部件PartA和PartB组成
//并声明一个得到产品建设后结果的方法GetResult
abstract class Builder
{
public abstract void BuildPartA();
public abstract void BuildPartB();
public abstract Product GetResult();
}
ConcreteBuilder类
class ConcreteBuilder1:Builder
{
private Product product = new Product();
public override void BuildPartA()//建造具体的两个部件是部件A和部件B
{
product.Add(“部件A”);
}
public override void BuildPartB()
{
product.Add(“部件B”);

    }
    public override Product GetResult()
    {
        return product;
    }
}

class ConcreteBuilder2:Builder
{
private Product product = new Product();
public override void BuildPartA()
{
product.Add(“部件A”);
}

    public override void BuildPartB()
    {
        product.Add("部件B");
    }
    public override Product GetResult()
    {
        return product;
    }
}

Director类
class Director
{
public void Construct(Builder builder )
{
builder.BuildPartA();
builder.BuildPartB();
}
}
客户端代码

Director director = new Director();
Builder b1 = new ConcreteBuilder1();
Builder b2 = new ConcreteBuilder2();

        director.Construct(b1);
        Product p1 = b1.GetResult();

        director.Construct(b2);
        Product p2 = b2.GetResult();
        p2.Show();

        Console.Read();

类图关系与代码表示
设计模式-建造者模式_其他_02

2.实际应用（建造小人）
瘦人类
class PersonThinBuilder : PersonBuilder
{
public PersonThinBuilder(Graphics g, Pen p)
: base(g, p)
{ }

public override void BuildHead()
{
    g.DrawEllipse(p, 50, 20, 30, 30);  //画椭圆
}

public override void BuildBody()        //画矩形
{
    g.DrawRectangle(p, 60, 50, 10, 50);
}

public override void BuildArmLeft()
{
    g.DrawLine(p, 60, 50, 40, 100);     //划线
}

public override void BuildArmRight()
{
    g.DrawLine(p, 70, 50, 90, 100);
}

public override void BuildLegLeft()
{
    g.DrawLine(p, 60, 100, 45, 150);
}

public override void BuildLegRight()
{
    g.DrawLine(p, 70, 100, 85, 150);
}

}
指挥者
class PersonDirector
{
private PersonBuilder pb;
public PersonDirector(PersonBuilder pb)
{
this.pb = pb;
}

public void CreatePerson()
{
    pb.BuildHead();
    pb.BuildBody();
    pb.BuildArmLeft();
    pb.BuildArmRight();
    pb.BuildLegLeft();
    pb.BuildLegRight();
}

}
客户端代码
private void button1_Click(object sender, EventArgs e)
{
Pen p = new Pen(Color.Yellow); //实例化一个画笔画笔颜色为黄色
PersonThinBuilder ptb = new PersonThinBuilder(pictureBox1.CreateGraphics(), p);//实例化一个瘦人并传参画板和画笔
PersonDirector pdThin = new PersonDirector(ptb); //实例化一个指挥者
pdThin.CreatePerson(); //指挥建造

        PersonFatBuilder pfb = new PersonFatBuilder(pictureBox2.CreateGraphics(), p);
        PersonDirector pdFat = new PersonDirector(pfb);
        pdFat.CreatePerson();

    }

相当知识点
CreateGraphics：为控件 创建Graphics
调用某控件或窗体的CreateGraphics方法以获取对Graphics对象的引用，该对象表示该控件或窗体的绘图图面。如果想在已存在的窗体或控件上绘图，通常会使用此方法。
Pen：用于绘制直线和曲线的对象，此类不能被继承。

六、设计知识点
1.构造方法
是对类进行初始化，构造方法与类同名
无返回值，也不需要void
在new的时候调用
所有类都有构造方法，如果你不编码则系统默认生成空的构造方法，若你有定义的构造方法，那么默认的构造方法就会失效。

2.访问修饰符
public：公有的，表示她所修饰的类成员可以允许其他任何类来访问。
private：私有的，表示只允许同一个类中的成员访问，其他类包括它的子类无法访问。
protected：保护的，只允许子类访问
internal：同一个项目中的代码访问，类默认的就是这个。

3.关系
本类涉及到的关系

聚合：关联关系的一种，表示整体和个体之间的关系，个体可以脱离整体而单独存在
实现：个体在整体中作为参数存在
图形：空心菱形+实心箭头

依赖：两个类之间的使用关系
实现：一个类作为另一个的方法的参数
图形：虚线+箭头
继承：类与类之间 类与接口之间 的继承关系
实现：子类继承父类（：）
图形：空心箭头+实线
4.抽象类
关键字：abstract
抽象类通常表示一个抽象概念，他提供一个继承的出发点，当设计一个新的抽象类时，一定是用来继承的，所以，在一个以继成关系形成的等级结构里面，树叶节点应当是具体类，而树叶节点均应当是抽象类

抽象类不能实例化
抽象方法是必须被子类重写的方法
如果类中包含抽象方法，那么类就必须定义为抽象类