通俗易懂设计模式解析——建造者模式

前言

　　在本篇文章中，我们重点介绍建造者模式（Builder Pattern），建造者模式顾名思义，与建造创建相关。事实也是如此建造者模式也是创建型中的一种。在我们平常生活中会有比较复杂的东西的组成过程。比如电脑组成、手机组成、电视组成、等等。就拿电脑组成来说。可以由主板、Cpu、显卡等等组成。但是组成的算法步骤是一样的。只是不同的东西组装起来结果不一样而已。

建造者模式介绍

一、来由

　　在软件编程的过程我们是否也会遇到类似电脑组装这类的问题呢？当然是会的。组装一个电脑我们就一次，那岂不是要累死了。类似于这种组装算法固定但是各个部分又不稳定经常变化的情况。并且对象组装较为复杂。为了面对解决这种情况。所以有建造者模式。建造者模式到底是如何解决问题的呢？我们一起看看吧。

二、意图

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

三、案例图

四、建造者模式代码示例

　　在建造者模式中一般包含如下成分：

抽象建造者：抽象建造者为创建复杂产品对象的各个部分指定抽象创建接口

具体建造者：继承抽象建造者，实现抽象创建接口。指定创建的类型。创建各个具体的部分。

产品角色：复杂产品对象，将各个部分组成产品的接口

指挥者：调用各个部分，按固定的算法创建。不涉及到具体产品类的信息。仅负责各个部分完整的创建

就组装电脑来说，我们一起看看建造者模式如何实现这一复杂对象的创建设计。

namespace Builder_Pattern
{
    public class BuilderPattern
    {
    }
    #region 产品角色——电脑的组成 ============
    public class Computer
    {
        private string Type = null;
        public Computer(string type)
        {
            this.Type = type;
        }
        private List<string> computer = new List<string>();
        public void Add(string part)
        {
            computer.Add(part);
        }

        public void Show()
        {
            Console.WriteLine("电脑组装正式开始：");
            foreach (var item in computer)
            {
                Console.WriteLine("配件——" + item + "已装好");
            }
            Console.WriteLine(Type + "电脑组装完成了");
        }
    }
    #endregion

    #region 抽象创建者——电脑中的各个部分的抽象接口============

    public abstract class Builder
    {
        /// <summary>
        /// Cpu抽象创建
        /// </summary>
        public abstract void CreateCpu();
        /// <summary>
        /// 主板抽象创建
        /// </summary>
        public abstract void CreateMotherboard();
        /// <summary>
        /// 显卡抽象创建
        /// </summary>
        public abstract void CreateGraphicsCard();
        /// <summary>
        /// 获取组装好的电脑
        /// </summary>
        /// <returns></returns>
        public abstract Computer GetComputer();

    }
    #endregion

    #region 具体产品创建者——联想电脑各个部分创建接口=========
    public class LenovoBuilder : Builder
    {
        Computer lenovo = new Computer("联想");
        public override void CreateCpu()
        {
            lenovo.Add("联想CPU");
        }
        public override void CreateMotherboard()
        {
            lenovo.Add("联想主板");
        }
        public override void CreateGraphicsCard()
        {
            lenovo.Add("联想显卡");
        }

        public override Computer GetComputer()
        {
            return lenovo;
        }
    }
    #endregion

    #region 具体产品创建者——惠普电脑各个部分创建接口=========
    public class HPBuilder : Builder
    {
        Computer hp = new Computer("惠普");
        public override void CreateCpu()
        {
            hp.Add("惠普CPU");
        }
        public override void CreateMotherboard()
        {
            hp.Add("惠普主板");
        }
        public override void CreateGraphicsCard()
        {
            hp.Add("惠普显卡");
        }

        public override Computer GetComputer()
        {
            return hp;
        }
    }
    #endregion

    #region 指挥者——固定的组装算法=================== 
    /// <summary>
    /// 指挥者，其中的Construct是组装的较为固定算法
    /// </summary>
    public class Commander
    {
        public void Construct(Builder builder)
        {
            builder.CreateMotherboard();
            builder.CreateCpu();
            builder.CreateGraphicsCard();
        }
    }
    #endregion
}

class Program
    {
        static void Main(string[] args)
        {
            //实例化指挥者
            Commander commander = new Commander();
            //指定具体产品
            Builder builder = new LenovoBuilder();
            //组装构建产品
            commander.Construct(builder);
            //构建完成展示产品
            Computer computer = builder.GetComputer();
            computer.Show();


            //指定具体产品
            builder = new HPBuilder();
            //组装构建产品
            commander.Construct(builder);
            //构建完成展示产品
            computer = builder.GetComputer();
            computer.Show();

            Console.ReadLine();
        }
    }

使用场景及优缺点

　　在建造者模式中，将一个复杂对象的组成与组件的创建分离开。专门的具体建造者来负责组件的创建、然后由指挥者来规定固定组成、最后完成组装。这一个过程下来。把复杂对象的创建拆分成多个步骤。而其组件也是经常变化的。这样一来组件的变化仅需修改增加组件的创建即可。不影响其他的扩展。这里由于建造者模式最终创建的产品差异较大，所以并没有抽象一个产品类。前面一章中讲的抽象工厂模式中解决的是”一系列产品对象”的问题。而本章中建造者模式解决的是”产品部分”的问题。抽象工厂模式关心的是整体，注重产品的创建，不关心细节的组成。而建造者模式关心的是细节，注重产品的创建的同时也关系产品组成细节的问题。

一、使用场景

1、当创建一个复杂对象且组成的算法独立与其组成部分的时候。

2、多个部件或配件可以装配到一个对象但产生的对象不同时。

3、创建一些复杂的对象时，这些对象的内部组成构件间的建造顺序是稳定的，但是对象的内部组成构件面临着复杂的变化。

二、优点

1、使用者客户端不必关心产品的组成及细节部分。

2、具体建造者与其他类相对独立，易于扩展。不易对其他模块造成影响

3、便于控制细节

三、缺点

1、产品必须有共同点，使用范围限制

2、如果内部变化较为复杂，会有较多的具体建造者类

总结

　　到这里介绍完了建造者模式，建造者模式与工厂模式相比，建造者模式更像生产的一个复合产品，并且复杂的部件不同所构成的不同，而工厂模式仅是产品。同时建造者模式关注复杂产品细节的创建。但是工厂模式仅关心产品的创建，不在乎其细节的创建。

　　　　做自己生命的主角，而不是别人生命中的看客。

　　C#设计模式系列目录

欢迎大家扫描下方二维码，和我一起踏上设计模式的闯关之路吧!

原文出处：https://www.cnblogs.com/hulizhong/p/11419220.html

来源：oschina

链接：https://my.oschina.net/u/4277474/blog/3254960

标签

commander