创建型模式 - 建造者模式Builder

学习而来，代码是自己敲的。也有些自己的理解在里边，有问题希望大家指出。

最近这个脑T---瘫----CSDN有毛病吧？我写这个都是涉及到广告了？谁家的广告？ 谁给我钱了？审核策略设计者是什么NTR？

模式的定义与特点

        建造者（Builder）模式的定义：指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。  

建造者模式的优点：

1. 封装性好，构建和表示分离。
2. 扩展性好，各个具体的建造者相互独立，有利于系统的解耦。
3. 客户端不必知道产品内部组成的细节，建造者可以对创建过程逐步细化，而不对其它模块产生任何影响，便于控制细节风险。

建造者模式的缺点：

1. 产品的组成部分必须相同，这限制了其使用范围。
2. 如果产品的内部变化复杂，如果产品内部发生变化，则建造者也要同步修改，后期维护成本较大。

---

        

        建造者（Builder）模式和工厂模式的关注点不同：建造者模式注重零部件的组装过程，而工厂方法模式( 抽象工厂模式、简单工厂模式)更注重零部件的创建过程，但两者可以结合使用。

模式的结构与实现

        建造者（Builder）模式由产品、抽象建造者、具体建造者、指挥者等 4 个要素构成，现在我们来分析其基本结构和实现方法。 

建造者（Builder）模式的主要角色如下。

1. 产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。
2. 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。
3. 具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
4. 指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

//============================================================客户端代码
#region Builder
public static void BuilderTest1()
{
    BuilderDirector director = new BuilderDirector();
    director.Build(new BuilderWorker()).BuilderProductToString();
    Console.WriteLine();
}

public static void BuilderTest2()
{
    BuilderDirector1 director1 = new BuilderDirector1();
    //按照客户制定的来
    BuilderWorker1 worker1 = new BuilderWorker1();
    worker1.BuildB("222BBB").BuildD("444DDD");
    director1.Build(worker1).BuilderProductToString();
    Console.WriteLine("=============分割线=============");
    //默认顺序
    BuilderWorker1 worker11 = new BuilderWorker1();
    director1.Build(worker11).BuilderProductToString();
    Console.WriteLine("=============分割线=============");

    //自己 换一个建造者 接着打造该产品
    worker1 = new BuilderWorker1(worker1.GetProduct());
    worker1.BuildB("我又修改了");
    director1.Build(worker1).BuilderProductToString();
}
#endregion


//============================================================建造者基类
namespace StudyDesignMode.Builder
{
    //工作服务者基类,按步骤流程 有顺序的来
    public abstract class Builder
    {
        public abstract void BuildA();
        public abstract void BuildB();
        public abstract void BuildC();
        public abstract void BuildD();
        public abstract BuilderProduct GetProduct(); 
    }

    //工作服务者基类,无序，按照客户要求来
    public abstract class Builder1
    {
        public abstract Builder1 BuildA(string builderMsg);
        public abstract Builder1 BuildB(string builderMsg);
        public abstract Builder1 BuildC(string builderMsg);
        public abstract Builder1 BuildD(string builderMsg);
        public abstract BuilderProduct GetProduct();
    }
}

//============================================================建造者类
namespace StudyDesignMode.Builder
{
    //工作服务者
    public class BuilderWorker : Builder
    {
        private BuilderProduct m_product;

        public BuilderWorker() { m_product = new BuilderProduct(); }

        public override void BuildA()
        {
            m_product.SetBuildA("Bulider_A");
            Console.WriteLine("Bulider_A");
        }

        public override void BuildB()
        {
            m_product.SetBuildB("Bulider_B");
            Console.WriteLine("Bulider_B");
        }

        public override void BuildC()
        {
            m_product.SetBuildC("Bulider_C");
            Console.WriteLine("Bulider_C");
        }

        public override void BuildD()
        {
            m_product.SetBuildD("Bulider_D");
            Console.WriteLine("Bulider_D");
        }

        public override BuilderProduct GetProduct(){ return m_product; }
    }

    public class BuilderWorker1 : Builder1
    {
        private BuilderProduct m_product;

        public BuilderWorker1() { m_product = new BuilderProduct(); }
        public BuilderWorker1(BuilderProduct product) { m_product = product; }
        public override Builder1 BuildA(string builderMsg)
        {
            m_product.SetBuildA(builderMsg);
            Console.WriteLine($"BuildA做出更改{builderMsg}");
            return this;
        }

        public override Builder1 BuildB(string builderMsg)
        {
            m_product.SetBuildB(builderMsg);
            Console.WriteLine($"BuildB做出更改{builderMsg}");
            return this;
        }

        public override Builder1 BuildC(string builderMsg)
        {
            m_product.SetBuildC(builderMsg);
            Console.WriteLine($"BuildC做出更改{builderMsg}");
            return this;
        }

        public override Builder1 BuildD(string builderMsg)
        {
            m_product.SetBuildD(builderMsg);
            Console.WriteLine($"BuildD做出更改{builderMsg}");
            return this;
        }

        public override BuilderProduct GetProduct() { return m_product; }
    }
}

//============================================================建造产品类
namespace StudyDesignMode.Builder
{
    public class BuilderProduct
    {
        private string builderA = "ProductA";
        private string builderB = "ProductB";
        private string builderC = "ProductC";
        private string builderD = "ProductD";

        public string GetBuildA(string build){ return builderA; }
        public void SetBuildA(string build){ builderA = build; }
        public string GetBuildB(string build) { return builderB; }
        public void SetBuildB(string build) { builderB = build; }
        public string GetBuildC(string build) { return builderC; }
        public void SetBuildC(string build) { builderC = build; }
        public string GetBuildD(string build) { return builderD; }
        public void SetBuildD(string build) { builderD = build; }

        public void BuilderProductToString()
        {
            Console.WriteLine($"builderA = {builderA}");
            Console.WriteLine($"builderB = {builderB}");
            Console.WriteLine($"builderC = {builderC}");
            Console.WriteLine($"builderD = {builderD}");
        }
    }
}


//============================================================指挥官类
namespace StudyDesignMode.Builder
{
    //指挥官
    public class BuilderDirector
    {
        public BuilderProduct Build(Builder builder)
        {
            builder.BuildA();
            builder.BuildB();
            builder.BuildC();
            builder.BuildD();
            return builder.GetProduct();
        }
    }

    public class BuilderDirector1
    {
        public BuilderProduct Build(Builder1 builder)
        {
            return builder.GetProduct();
        }
    }
}

总结

用例子来说比较清楚明了：

假设我们目前有一个需求，有好多不同的工厂，其中的飞机场需要建造战斗机去战斗。

        那我们需要通过抽象工厂模式或者工厂模式，编写不同的工厂，然后在其中的飞机工厂中获取飞机。那么飞机工厂只能提供已经组装好的飞机，那组装好的飞机从何而来？  这就需要我们通过建造者模式，去把战斗机的零件一个一个的生产出来，然后提供给飞机工厂。

---

希望大家：点赞，留言，关注咯~    

唠家常

• Xiaohei.Wang(Wenhao)的今日分享结束啦，小伙伴们你们get到了么，你们有没有更好的办法呢，可以评论区留言分享，也可以加我的QQ：841298494 (记得备注)，大家一起进步

今日无推荐

• 客官，看完get之后记得点赞哟！
• 小伙伴你还想要别的知识？好的呀，分享给你们
• 小黑的杂货铺，想要什么都有，客官不进来喝杯茶么？