【设计模式】 之 建造者模式

概念：

建造者模式（Builder）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

解释说明：

1.当我们要进行一系列步骤，或者要实现一组方法，可能参数最后的结果不一样，但这些步骤都一样。和做菜一个道理，回回都是那几步，但每步具体是不一样的。

2.建造者模式就是做出一个框定步骤的类，最后调用这个类实现一下就好了。

建造者模式实现：

1.做一个抽象类，方便代码的复用

abstract class PersonBuilder
    {
        protected Graphics g;
        protected Pen p;

        public PersonBuilder(Graphics g, Pen p)
        {
            this.g = g;
            this.p = p;
        }

        public abstract void BuildHead();
        public abstract void BuildBody();
        public abstract void BuildArmLeft();
        public abstract void BuildArmRight();
        public abstract void BuildLegLeft();
        public abstract void BuildLegRight();

    }

这是一个画小人的例子，抽象类中确定画小人的各个方法

2.各个具体的子类继承抽象类，分别建造出步骤相同、复杂的但其实是不同的子类

class PersonThinBuilder:PersonBuilder
    {
        public PersonThinBuilder (Graphics g,Pen p):base(g,p)
        {}

        public override void BuildHead()
        {
            g.DrawEllipse(10,50,20,30,30);
        }

        public override void BuildBody()
        {
            g.DrawEllipse(10, 50, 20, 30, 30);
        }

        public override void BuildArmLeft()
        {
            g.DrawEllipse(10, 50, 20, 30, 30);
        }

        public override void BuildArmRight()
        {
            g.DrawEllipse(10, 50, 20, 30, 30);
        }

        public override void BuildLegLeft()
        {
            g.DrawEllipse(10, 50, 20, 30, 30);
        }

        public override void BuildLegRight()
        {
            g.DrawEllipse(10, 50, 20, 30, 30);
        }
    }

具体的子类继承抽象类，画出一个瘦瘦的小人，可以看出这个子类封装了复杂的过程。

3.做一个指挥者的类，它的功能就是一条条实现传入进来（子类实例化的）对象的过程，但是它这个功能是写死的，每个过程都执行，要是传进来的（子类实例化出来的）对象它本身少几条，那么就执行不了，编译错误。

class PersonDirector
    {
        private PersonBuilder pb;

        public PersonDirector(PersonBuilder pb)
        {
            this.pb = pb;
        }

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

指挥者这个类就是把传入它的实例化成功的那个瘦小人的功能一条条执行，但是如果原来的瘦小人那个类忘了写一步，那么很明显这里执行不了，程序都不会编译（检查子类的小能手~~）。

4.最后，客户端直接调用指挥者那一个功能就OK了。

static void Main(string[] args)
        {
            Pen p =new Pen();
            PersonThinBuilder ptb=new PersonThinBuilder (pictureBox1.createGraphics(),p);
            PersonDirector pdThin=new PersonDirector (ptb );
            pdThin .CreatPerson ();
        }

调用指挥者，让他直接画就好了。

总结：

其实这个和做菜一样一样的，没什么区别。
不管哪种菜（具体的子类），在菜谱流程中都必须说盐、油、时间（复杂的构建过程）的多少，那么谁来检查执行呢？就是厨师，这里面哪怕少一步，他就不会做，最后客户端就是直接调用厨师的做菜功能就OK了。
这个模式的作用就是让扩展出来的每一个子类（新增加的菜种），都是可以执行的，而且客户端可以不受影响直接的执行。

——本学习总结参考书籍为《大话设计模式》作者：程杰