zoukankan      html  css  js  c++  java
  • 第四节:组合模式和建筑者模式详解

    一. 组合模式

    1. 背景

     在现实生活中,存在很多“部分-整体”的关系,例如,大学中的部门与学院、总公司中的部门与分公司、学习用品中的书与书包、生活用品中的衣月艮与衣柜以及厨房中的锅碗瓢盆等。在软件开发中也是这样,例如,文件系统中的文件与文件夹、窗体程序中的简单控件与容器控件等。对这些简单对象与复合对象的处理,如果用组合模式来实现会很方便。

    2. 定义和特点

    (1). 定义:有时又叫作部分-整体模式,它是一种将对象组合成树状的层次结构的模式,用来表示“部分-整体”的关系,使用户对单个对象和组合对象具有一致的访问性。

    (2). 优点:

      A. 组合模式使得客户端代码可以一致地处理单个对象和组合对象,无须关心自己处理的是单个对象,还是组合对象,这简化了客户端代码;

      B. 更容易在组合体内加入新的对象,客户端不会因为加入了新的对象而更改源代码,满足“开闭原则”;

    (3). 缺点

      A. 设计较复杂,客户端需要花更多时间理清类之间的层次关系;

      B. 不容易限制容器中的构件;

      C. 不容易用继承的方法来增加构件的新功能;

    3. 具体实现

    (1). 模式结构

        可以自身嵌套结构。

    (2). 使用场景

       存储上下级关系,CEO→技术主管→员工;CEO→销售主管→员工。

    (3). 代码实操

    上下级自身嵌套代码:

         /// <summary>
        /// 员工类
        /// </summary>
        public class Employee
        {
            private string name;
            private string dept;
            private int salary;
            //代表下级子类
            private List<Employee> subordinates;
    
            //构造函数
            public Employee(string name, string dept, int sal)
            {
                this.name = name;
                this.dept = dept;
                this.salary = sal;
                subordinates = new List<Employee>();
            }
    
            public void add(Employee e)
            {
                subordinates.Add(e);
            }
    
            public void remove(Employee e)
            {
                subordinates.Remove(e);
            }
    
            public List<Employee> getSubordinates()
            {
                return subordinates;
            }
    
            public string toString()
            {
                return ("Employee :[ Name : " + name
                + ", dept : " + dept + ", salary :"
                + salary + " ]");
            }
        }
    View Code

    测试代码:

                {
                    // 1、树形机构的场景,使用组合模式
                    Employee CEO = new Employee("张三", "CEO", 30000);
    
                    Employee headMarketing = new Employee("李四", "技术经理", 20000);
                    Employee headSales = new Employee("王五", "销售经理", 20000);
    
                    Employee clerk1 = new Employee("赵六", "销售", 10000);
                    Employee clerk2 = new Employee("钱七", "销售", 10000);
    
                    Employee salesExecutive1 = new Employee("Tony", "技术", 10000);
                    Employee salesExecutive2 = new Employee("Mark", "技术", 10000);
    
                    CEO.add(headSales);
                    CEO.add(headMarketing);
    
                    headSales.add(clerk1);
                    headSales.add(clerk2);
    
                    headMarketing.add(salesExecutive1);
                    headMarketing.add(salesExecutive2);
    
                    //打印该组织的所有员工
                    Console.WriteLine(CEO.toString());
                    foreach (Employee headEmployee in CEO.getSubordinates())
                    {
                        Console.WriteLine(headEmployee.toString());
                        foreach (Employee employee in headEmployee.getSubordinates())
                        {
                            Console.WriteLine(employee.toString());
                        }
                    }
                }

    运行结果:

     

    4. 适用场景分析 

     A. 在需要表示一个对象整体与部分的层次结构的场合。

     B. 要求对用户隐藏组合对象与单个对象的不同,用户可以用统一的接口使用组合结构中的所有对象的场合。

    二. 建筑者模式

    1. 背景

     在软件开发过程中有时需要创建一个复杂的对象,这个复杂对象通常由多个子部件按一定的步骤组合而成。例如,计算机是由 OPU、主板、内存、硬盘、显卡、机箱、显示器、键盘、鼠标等部件组装而成的,采购员不可能自己去组装计算机,而是将计算机的配置要求告诉计算机销售公司,计算机销售公司安排技术人员去组装计算机,然后再交给要买计算机的采购员。

     生活中这样的例子很多,如游戏中的不同角色,其性别、个性、能力、脸型、体型、服装、发型等特性都有所差异;还有汽车中的方向盘、发动机、车架、轮胎等部件也多种多样;每封电子邮件的发件人、收件人、主题、内容、附件等内容也各不相同。

     以上所有这些产品都是由多个部件构成的,各个部件可以灵活选择,但其创建步骤都大同小异。这类产品的创建无法用前面介绍的工厂模式描述,只有建造者模式可以很好地描述该类产品的创建。

    2. 定义和特点

    (1). 定义

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

    (2). 优点

     A. 各个具体的建造者相互独立,有利于系统的扩展。

     B. 客户端不必知道产品内部组成的细节,便于控制细节风险。

    (3). 缺点

     A. 产品的组成部分必须相同,这限制了其使用范围。

     B. 如果产品的内部变化复杂,该模式会增加很多的建造者类。

    (4). 与工厂方法模式的区别

     建造者模式注重零部件的组装过程,而工厂方模式更注重零部件的创建过程,但两者可以结合使用。

    3. 具体实现

    (1). 模式结构

     建造者(Builder)模式由产品、抽象建造者、具体建造者、指挥者等 4 个要素构成。  

     A. 产品角色(Product):它是包含多个组成部件的复杂对象,由具体建造者来创建其各个零部件。

     B. 抽象建造者(Builder):它是一个包含创建产品各个子部件的抽象方法的接口,通常还包含一个返回复杂产品的方法 getResult()。

     C. 具体建造者(Concrete Builder):实现 Builder 接口,完成复杂产品的各个部件的具体创建方法。

     D. 指挥者(Director):它调用建造者对象中的部件构造与装配方法完成复杂对象的创建,在指挥者中不涉及具体产品的信息。

    PS:如果创建的产品种类只有一种,只需要一个具体建造者,这时可以省略掉抽象建造者,甚至可以省略掉指挥者角色。

    结构图如下:

    (2). 使用场景

      现在要构建自行车,包括核心组件frame、seat、tire,而每个组件可选的材料有多种,自行车的构建顺序是固定的,比如按照这个顺序:BuidFrame、BuildSeat、BuildTire。这个场景就可以使用建筑者模式。

    (3). 代码实操

    各种自行车材料代码:

        /// <summary>
        /// 自行车框架
        /// </summary>
        public interface IFrame
        {
            void show();
        }
        /// <summary>
        /// 自行车座椅
        /// </summary>
        public interface ISeat
        {
            void show();
        }
         /// <summary>
        /// 自行车轮胎
        /// </summary>
        public interface ITire
        {
            void show();
        }
        /// <summary>
        /// 合金自行车框架1
        /// </summary>
        public class AlloyFrame1 : IFrame
        {
            public void show()
            {
                Console.WriteLine("我是合金自行车框架1");
            }
        }
        /// <summary>
        /// 合金自行车框架2
        /// </summary>
        public class AlloyFrame2 : IFrame
        {
            public void show()
            {
                Console.WriteLine("我是合金自行车框架2");
            }
        }
        /// <summary>
        /// 真皮座椅1
        /// </summary>
        public class DermisSeat1 : ISeat
        {
            public void show()
            {
                Console.WriteLine("我是真皮座椅1");
            }
        }
        /// <summary>
        /// 真皮座椅2
        /// </summary>
        public class DermisSeat2 : ISeat
        {
            public void show()
            {
                Console.WriteLine("我是真皮座椅2");
            }
        }
         /// <summary>
        /// 结实的轮胎1
        /// </summary>
        public class SolidTire1 : ITire
        {
            public void show()
            {
                Console.WriteLine("我是结实的轮胎1");
            }
        }
        /// <summary>
        /// 结实的轮胎2
        /// </summary>
        public class SolidTire2 : ITire
        {
            public void show()
            {
                Console.WriteLine("我是结实的轮胎2");
            }
        }
    View Code

    自行车代码:

     /// <summary>
        /// 自行车类
        /// </summary>
        public class Bike
        {
            /// <summary>
            /// 自行车框架
            /// </summary>
            public IFrame frame { set; get; }
            /// <summary>
            /// 自行车座椅
            /// </summary>
            public ISeat seat { set; get; }
            /// <summary>
            /// 自行车 轮胎
            /// </summary>
            public ITire tire { set; get; }
    
            /// <summary>
            /// 获取自行车的详情信息
            /// </summary>
            public void GetDetils()
            {
                Console.WriteLine("自行车的详细信息如下:");
                frame.show();
                seat.show();
                tire.show();
            }
        }
    View Code

    抽象建筑者和具体建筑者:

     /// <summary>
        /// 抽象建筑者类
        /// 如果只有一个具体的建筑者类,则可以省略该抽象建筑者类的
        /// </summary>
        public abstract class AbstractBuilder
        {
            public Bike mBike = new Bike();
    
            public abstract void BuildFrame();
    
            public abstract void BuildSeat();
    
            public abstract void BuildTire();
    
            /// <summary>
            /// 返回自行车对象
            /// </summary>
            /// <returns></returns>
            public abstract Bike Build();
           
    
        }
     /// <summary>
        /// 自行车建筑者类1
        /// </summary>
        public class BikeBuilder1: AbstractBuilder
        {
            /// <summary>
            /// 构建frame
            /// </summary>
            public override void BuildFrame()
            {
                mBike.frame = new AlloyFrame1();
            }
    
            /// <summary>
            /// 构建seat
            /// </summary>
            public override void BuildSeat()
            {
                mBike.seat = new DermisSeat1();
            }
    
            /// <summary>
            /// 构建tire
            /// </summary>
            public override void BuildTire()
            {
                mBike.tire = new SolidTire1();
            }
    
            /// <summary>
            /// 返回直行车对象
            /// </summary>
            /// <returns></returns>
            public override Bike Build()
            {
                return mBike;
            }
        }
      /// <summary>
        /// 自行车建筑者类2
        /// </summary>
        public class BikeBuilder2 : AbstractBuilder
        {
            /// <summary>
            /// 构建frame
            /// </summary>
            public override void BuildFrame()
            {
                mBike.frame = new AlloyFrame2();
            }
    
            /// <summary>
            /// 构建seat
            /// </summary>
            public override void BuildSeat()
            {
                mBike.seat = new DermisSeat2();
            }
    
            /// <summary>
            /// 构建tire
            /// </summary>
            public override void BuildTire()
            {
                mBike.tire = new SolidTire2();
            }
    
            /// <summary>
            /// 返回直行车对象
            /// </summary>
            /// <returns></returns>
            public override Bike Build()
            {
                return mBike;
            }
        }
    View Code

    指挥者:

      /// <summary>
        /// 指挥者
        /// 调用建造者中的方法完成复杂对象的创建
        /// 如果只有一个建筑者的话,可以省略该指挥者的角色
        /// </summary>
        public class BikeDirector
        {
            private AbstractBuilder _builder;
            public BikeDirector(AbstractBuilder builder)
            {
                this._builder = builder;
            }
            /// <summary>
            /// Bike的构建和组装
            /// </summary>
            /// <returns></returns>
            public Bike CreateBike()
            {
                _builder.BuildFrame();
                _builder.BuildSeat();
                _builder.BuildTire();
    
                return _builder.Build();
            }
        }
    View Code

    测试代码:

                    //1.普通模式
                    {
                        Console.WriteLine("-------------------下面是普通模式构建自行车-------------------------");
                        //1. 构建自行车
                        Bike b = new Bike();
                        b.frame = new AlloyFrame1();
                        b.seat = new DermisSeat2();
                        b.tire = new SolidTire1();
    
                        //2. 输出自行车信息
                        b.GetDetils();
                    }
    
                    //2. 使用建筑者模式
                    {
                        Console.WriteLine("-------------------下面是使用建筑者模式构建自行车-------------------------");
                        //1. 构建建筑者
                        BikeBuilder1 builder = new BikeBuilder1();
                        builder.BuildFrame();
                        builder.BuildSeat();
                        builder.BuildTire();
                        //2. 构建自行车
                        Bike bike = builder.Build();
                        //3. 输出自行车的信息
                        bike.GetDetils();
                    }
    
                    //3. 引入抽象建筑者父类
                    {
                        Console.WriteLine("-------------------下面是 引入抽象建筑者父类 构建自行车-------------------------");
                        //1. 构建建筑者1
                        AbstractBuilder builder = new BikeBuilder1();
                        builder.BuildFrame();
                        builder.BuildSeat();
                        builder.BuildTire();
                        //2. 构建自行车
                        Bike bike = builder.Build();
                        //3. 输出自行车的信息
                        bike.GetDetils();
    
                        //1. 构建建筑者2
                        AbstractBuilder builder2 = new BikeBuilder2();
                        builder2.BuildFrame();
                        builder2.BuildSeat();
                        builder2.BuildTire();
                        //2. 构建自行车
                        Bike bike2 = builder2.Build();
                        //3. 输出自行车的信息
                        bike2.GetDetils();
                    }
    
                    //4. 引入指挥者
                    {
                        Console.WriteLine("-------------------下面是 引入指挥者 构建自行车-------------------------");
                        //指挥者1
                        BikeDirector dirctor1 = new BikeDirector(new BikeBuilder1());
                        Bike bike1 = dirctor1.CreateBike();
                        bike1.GetDetils();
    
                        //指挥者2
                        BikeDirector dirctor2 = new BikeDirector(new BikeBuilder2());
                        Bike bike2 = dirctor2.CreateBike();
                        bike2.GetDetils();
                    }

    运行效果:

     

    4. 适用场景分析

     建造者(Builder)模式创建的是复杂对象,其产品的各个部分经常面临着剧烈的变化,但将它们组合在一起的算法却相对稳定,所以它通常在以下场合使用。

     A. 创建的对象较复杂,由多个部件构成,各部件面临着复杂的变化,但构件间的建造顺序是稳定的。

     B. 创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式,即产品的构建过程和最终的表示是独立的。

     

    !

    • 作       者 : Yaopengfei(姚鹏飞)
    • 博客地址 : http://www.cnblogs.com/yaopengfei/
    • 声     明1 : 如有错误,欢迎讨论,请勿谩骂^_^。
    • 声     明2 : 原创博客请在转载时保留原文链接或在文章开头加上本人博客地址,否则保留追究法律责任的权利。
     
  • 相关阅读:
    js 把数组中每个元素的某个字段取出
    vue 实现单选/多选效果
    js常用的array方法
    js的split()和join()的用法
    HTML 转 PDF 之 wkhtmltopdf
    微信小程序api封装(promise)
    常用的正则表达式
    更改MySQL的存储目录
    CentOS 6.X 安装VirtualBox-5.1
    CentOS 6.X 安装VNC Server实现图形化访问
  • 原文地址:https://www.cnblogs.com/yaopengfei/p/13462519.html
Copyright © 2011-2022 走看看