当前位置: 澳门新濠3559 > 编程 > 正文

如果需要修改产品的内部表示澳门新濠3559,一步

时间:2019-10-07 13:19来源:编程
public interface VehicleBuilder { void buildEngine(); void buildWheel(); Vehicle getVehicle();} ①  创建复杂对象的算法是独立于它的组成部件及装配过程。 模式动机         无论是在现实世界中还是在
public interface VehicleBuilder { void buildEngine(); void buildWheel(); Vehicle getVehicle();}

①  创建复杂对象的算法是独立于它的组成部件及装配过程。

模式动机

        无论是在现实世界中还是在软件系统中,都存在一些复杂的对象,它们拥有多个组成部分,如汽车,它包括车轮、方向盘、发送机等各种部件。而对于大多数用户而言,无须知道这些部件的装配细节,也几乎不会使用单独某个部件,而是使用一辆完整的汽车,可以通过建造者模式对其进行设计与描述,建造者模式可以将部件和其组装过程分开,一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象,而无须知道其内部的具体构造细节

        在软件开发中,也存在大量类似汽车一样的复杂对象,它们拥有一系列成员属性,这些成员属性中有些是引用类型的成员对象。而且在这些复杂对象中,还可能存在一些限制条件,如某些属性没有赋值则复杂对象不能作为一个完整的产品使用;有些属性的赋值必须按照某个顺序,一个属性没有赋值之前,另一个属性可能无法赋值等。

        复杂对象相当于一辆有待建造的汽车,而对象的属性相当于汽车的部件,建造产品的过程就相当于组合部件的过程。由于组合部件的过程很复杂,因此,这些部件的组合过程往往被“外部化”到一个称作建造者的对象里建造者返还给客户端的是一个已经建造完毕的完整产品对象,而用户无须关心该对象所包含的属性以及它们的组装方式,这就是建造者模式的模式动机。


    class Program
    {
        static void Main(string[] args)
        {
            Director director = new Director();
            Builder b1 = new ConcreteBuilder1();
            Builder b2 = new ConcreteBuilder2();
            director.Constrct(b1);
            Product p1 = b1.GetResult();
            p1.Show();

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

            Console.ReadLine();
        }
    }

建造者模式实现了建造代码与表示的分离,产品的内部表示由具体建造者负责,而组装过程迁移到指挥者来单独实现。并且具体建造者之间是相互独立的,有利于程序的扩展,如果需要修改产品的内部表示,只需要再定义一个具体的建造者就可以了。

Product:产品角色
  ❶  被构建的复杂对象,具体建造者创建该产品的内部表示并定义它的装配过程。
  ❷ 包含定义组成部件的类,包括将这些部件装配成最终产品的接口。

模式分析

        抽象建造者类中定义了产品的创建方法和返回方法;

        建造者模式的结构中还引入了一个指挥者类Director,该类的作用主要有两个:一方面它隔离了客户与生产过程;另一方面它负责控制产品的生成过程。指挥者针对抽象建造者编程,客户端只需要知道具体建造者的类型,即可通过指挥者类调用建造者的相关方法,返回一个完整的产品对象

        在客户端代码中,无须关心产品对象的具体组装过程,只需确定具体建造者的类型即可,建造者模式将复杂对象的构建与对象的表现分离开来,这样使得同样的构建过程可以创建出不同的表现。


 澳门新濠3559 1

(四)案例分析:车间造车

模式结构

建造者模式包含如下角色:

Builder:抽象建造者(给出一个抽象接口,以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建,并不涉及具体的对象部件的创建。)

ConcreteBuilder:具体建造者(实现Builder接口,针对不同的商业逻辑,具体化复杂对象的各部分的创建。 在建造过程完成后,提供产品的实例)

Director:指挥者(调用具体建造者来创建复杂对象的各个部分,在指导者中不涉及具体产品的信息,只负责保证对象各部分完整创建或按某种顺序创建)

Product:产品角色

澳门新濠3559 2

澳门新濠3559 3

澳门新濠3559 4

澳门新濠3559 5

澳门新濠3559 6

澳门新濠3559 7


Director就是构建一个使用Builder接口的对象。

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

ConcreteBuilder:具体建造者。实现Builder接口。
  ❶  构造和装配产品的各个部件。
  ❷  定义并明确它所创建的表示。
  ❸  提供一个返回这个产品的接口。

模式扩展

建造者模式的简化:

如果需要修改产品的内部表示澳门新濠3559,一步一步创建一个复杂的对象。        省略抽象建造者角色:如果系统中只需要一个具体建造者的话,可以省略掉抽象建造者。

        省略指挥者角色:在具体建造者只有一个的情况下,如果抽象建造者角色已经被省略掉,那么还可以省略指挥者角色,让Builder角色扮演指挥者与建造者双重角色。

 建造者模式与抽象工厂模式的比较:

        与抽象工厂模式相比, 建造者模式返回一个组装好的完整产品 ,而抽象工厂模式返回一系列相关的产品,这些产品位于不同的产品等级结构,构成了一个产品族。

        在抽象工厂模式中,客户端实例化工厂类,然后调用工厂方法获取所需产品对象,而在建造者模式中,客户端可以不直接调用建造者的相关方法,而是通过指挥者类来指导如何生成对象,包括对象的组装过程和建造步骤,它侧重于一步步构造一个复杂对象,返回一个完整的对象。

        如果将抽象工厂模式看成 汽车配件生产工厂 ,生产一个产品族的产品,那么建造者模式就是一个 汽车组装工厂 ,通过对部件的组装可以返回一辆完整的汽车。


第二个Show就是展示产品所拥有的部件

public class Vehicle { List<String> partList = new ArrayList<>(); public void addPart(String part) { partList.add; } public void show() { for (String part : partList) { System.out.println; } }}

(一)定义:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。建造者模式是一步一步创建一个复杂的对象,它允许用户只通过指定复杂对象的类型和内容就可以构建它们。用户不知道内部的具体构建细节。

缺点

        建造者模式所创建的产品一般具有较多的共同点其组成部分相似,如果产品之间的差异性很大,则不适合使用建造者模式,因此其使用范围受到一定的限制。

        如果产品的内部变化复杂,可能会导致需要定义很多具体建造者类来实现这种变化,导致系统变得很庞大。


第一个Add方法主要是为产品添加部件

生产一辆车,需要建造发动机、车轮等,车辆在这里就是具体产品。车辆建造者定义了建造发动机、车轮的接口,承担了抽象建造者的角色。小轿车建造者是一个具体的建造者,用于建造小轿车这一个类型。指挥者负责组装车辆。

缺点:如果产品之间的差异性很大,这就需要借助工厂方法模式或抽象工厂模式。另外,如果产品的内部变化复杂,Builder的每一个子类都需要对应到不同的产品去做构建的动作,这就需要定义很多个具体建造者类来实现这种变化。

总结

        建造者模式将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。建造者模式是一步一步创建一个复杂的对象,它允许用户只通过指定复杂对象的类型和内容就可以构建它们,用户不需要知道内部的具体构建细节。建造者模式属于对象创建型模式。

        建造者模式包含如下四个角色:抽象建造者为创建一个产品对象的各个部件指定抽象接口;具体建造者实现了抽象建造者接口,实现各个部件的构造和装配方法,定义并明确它所创建的复杂对象,也可以提供一个方法返回创建好的复杂产品对象;产品角色是被构建的复杂对象,包含多个组成部件;指挥者负责安排复杂对象的建造次序,指挥者与抽象建造者之间存在关联关系,可以在其construct()建造方法中调用建造者对象的部件构造与装配方法,完成复杂对象的建造。

        在建造者模式的结构中引入了一个指挥者类,该类的作用主要有两个:一方面它隔离了客户与生产过程;另一方面它负责控制产品的生成过程。指挥者针对抽象建造者编程,客户端只需要知道具体建造者的类型,即可通过指挥者类调用建造者的相关方法,返回一个完整的产品对象。

        建造者模式的主要优点在于客户端不必知道产品内部组成的细节,将产品本身与产品的创建过程解耦,使得相同的创建过程可以创建不同的产品对象,每一个具体建造者都相对独立,而与其他的具体建造者无关,因此可以很方便地替换具体建造者或增加新的具体建造者,符合“开闭原则”,还可以更加精细地控制产品的创建过程;其主要缺点在于由于建造者模式所创建的产品一般具有较多的共同点,其组成部分相似,因此其使用范围受到一定的限制,如果产品的内部变化复杂,可能会导致需要定义很多具体建造者类来实现这种变化,导致系统变得很庞大。

        建造者模式适用情况包括:需要生成的产品对象有复杂的内部结构,这些产品对象通常包含多个成员属性;需要生成的产品对象的属性相互依赖,需要指定其生成顺序;对象的创建过程独立于创建该对象的类;隔离复杂对象的创建和使用,并使得相同的创建过程可以创建不同类型的产品。


Product具体产品角色

  1. 抽象建造者:定义创建一个产品对象的各个部件的接口。
  2. 具体建造者:实现抽象建造者,构造和装配各个部件。
  3. 指挥者:构建一个使用抽象建造者的对象。
  4. 具体产品:产品本身。

Director:指挥者。构建一个使用Builder接口的对象。

模式定义

        建造者模式(Builder Pattern):将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示

澳门新濠3559,        建造者模式是一步一步创建一个复杂的对象,它允许用户只通过指定复杂对象的类型和内容就可以构建它们,用户不需要知道内部的具体构建细节。建造者模式属于对象创建型模式。根据中文翻译的不同,建造者模式又可以称为生成器模式。


Builder类---抽象建造类,确定产品由两个部件PartA和PartB组成,并声明一个得到产品建造后结果的方法GetResult。

Builder:抽象建造者。为创建一个Product对象的各个部件指定抽象接口。

模式应用

        在很多游戏软件中,地图包括天空、地面、背景等组成部分,人物角色包括人体、服装、装备等组成部分,可以使用建造者模式对其进行设计,通过不同的具体建造者创建不同类型的地图或人物。


ConcreteBuilder是具体的建造者,实现Builder接口,构造和装配各个部件。可以有多个不同的具体的建造者。

澳门新濠3559 8建造者模式类图

(五)建造者模式的适用性及优缺点分析

实例

实例:KFC套餐

        建造者模式可以用于描述KFC如何创建套餐:套餐是一个复杂对象,它一般包含主食(如汉堡、鸡肉卷等)和饮料(如果汁、 可乐等)等组成部分,不同的套餐有不同的组成部分,而KFC的服务员可以根据顾客的要求,一步一步装配这些组成部分,构造一份完整的套餐,然后返回给顾客。

澳门新濠3559 9


 澳门新濠3559 10

  • 车辆

创建一些复杂的对象,这些对象内部构建间的建造顺序通常是稳定的,但对象内部的构建通常面临着复杂的变化。

适用环境

        在以下情况下可以使用建造者模式:

        需要生成的产品对象有复杂的内部结构,这些产品对象通常包含多个成员属性。

        需要生成的产品对象的属性相互依赖,需要指定其生成顺序。

        对象的创建过程独立于创建该对象的类。在建造者模式中引入了指挥者类,将创建过程封装在指挥者类中,而不在建造者类中。

        隔离复杂对象的创建和使用,并使得相同的创建过程可以创建不同的产品。


代码实现

public class SedanBuilder implements VehicleBuilder { private Vehicle vehicle = new Vehicle(); @Override public void buildEngine() { vehicle.addPart("one engine"); } @Override public void buildWheel() { vehicle.addPart("four wheel"); } @Override public Vehicle getVehicle() { return vehicle; }}

澳门新濠3559 11

优点

        在建造者模式中, 客户端不必知道产品内部组成的细节,将产品本身与产品的创建过程解耦,使得相同的创建过程可以创建不同的产品对象。

        每一个具体建造者都相对独立,而与其他的具体建造者无关,因此可以很方便地替换具体建造者或增加新的具体建造者,用户使用不同的具体建造者即可得到不同的产品对象 。

        可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中,使得创建过程更加清晰,也更方便使用程序来控制创建过程。

        增加新的具体建造者无须修改原有类库的代码,指挥者类针对抽象建造者类编程,系统扩展方便,符合“开闭原则”。


总结

适用性:

结构图

  • 小轿车建造者

UML类图:抽象不应该依赖细节,细节应该依赖于抽象

    public class Director
    {
        public void Constrct(Builder builder)
        {
            builder.BuildPartA();
            builder.BuildPartB();
        }
    }

建造者模式主要用于创建一下复杂的对象,这些对象内部构件的建造顺序通常是稳定的,但对象内部的构建通常面临复杂的变化。

源码using System;
using System.Collections;
using System.Text;

namespace 设计模式.生成器模式
{
    public class Shop
    {
        public Shop(VehicleBuilder vehicleBuilder)
        {
            vehicleBuilder.BuildFrame();
            vehicleBuilder.BuildEngine();
            vehicleBuilder.BuildWheels();
            vehicleBuilder.BuildDoors();
        }
    }

    public abstract class VehicleBuilder
    {
        protected Vehicle vehicle;
        public Vehicle Vehicle
        {
            get
            {
                return vehicle;
            }
        }
        public abstract void BuildFrame();
        public abstract void BuildEngine();
        public abstract void BuildWheels();
        public abstract void BuildDoors();
    }

    public class MotorCycleBuilder : VehicleBuilder
    {
        public override void BuildFrame()
        {
            vehicle = new Vehicle("摩托车");
            vehicle["frame"] = "MotorCycle Frame";
        }

        public override void BuildEngine()
        {
            vehicle["engine"] = "500 CC";
        }

        public override void BuildWheels()
        {
            vehicle["wheels"] = "2";
        }

        public override void BuildDoors()
        {
            vehicle["doors"] = "0";
        }
    }

    public class CarBuilder : VehicleBuilder
    {

        public override void BuildFrame()
        {
            vehicle = new Vehicle("轿车");
            vehicle["frame"] = "Car Frame";
        }

        public override void BuildEngine()
        {
            vehicle["engine"] = "2500 CC";
        }

        public override void BuildWheels()
        {
            vehicle["wheels"] = "4";
        }

        public override void BuildDoors()
        {
            vehicle["doors"] = "4";
        }
    }

    public class ScooterBuilder : VehicleBuilder
    {

        public override void BuildFrame()
        {
            vehicle = new Vehicle("单脚滑行车");
            vehicle["frame"] = "Scooter Frame";
        }

        public override void BuildEngine()
        {
            vehicle["engine"] = "none";
        }

        public override void BuildWheels()
        {
            vehicle["wheels"] = "2";
        }

        public override void BuildDoors()
        {
            vehicle["doors"] = "0";
        }
    }

    public class Vehicle
    {
        private string type;
        private Hashtable parts = new Hashtable();

        public Vehicle(string type)
        {
            this.type = type;
        }

        public object this[string key]
        {
            get { return parts[key]; }
            set { parts[key] = value; }
        }

        public string Show()
        {
            Console.WriteLine("n----------------------------------");
            Console.WriteLine("车辆类型:"   type);
            Console.WriteLine(" 框架:"   parts["frame"]);
            Console.WriteLine(" 发动机:"   parts["engine"]);
            Console.WriteLine(" #轮子数:"   parts["wheels"]);
            Console.WriteLine(" #车门数:"   parts["doors"]);

            StringBuilder sb=new StringBuilder();
            sb.AppendFormat("车辆类型:{0}",type).AppendLine();
            sb.AppendFormat(" 框架:{0}",parts["frame"]).AppendLine();
            sb.AppendFormat(" 发动机:{0}",parts["engine"]).AppendLine();
            sb.AppendFormat(" #轮子数:{0}", parts["wheels"]).AppendLine();
            sb.AppendFormat(" #车门数:{0}" , parts["doors"]);
            return sb.ToString();
        }
    }
}

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

(二)类与对象之间的关系:

最终运行效果

  • 客户端测试类

澳门新濠3559 12

    public class Product
    {
        List<string> parts = new List<string>();
        public void Add(string part)
        {
            parts.Add(part);
        }

        public void Show()
        {
            Console.WriteLine("n产品 创建…………");
            foreach (string part in parts)
            {
                Console.WriteLine(part);
            }
        }
    }
  • 车辆建造者

(三)时序图:

ConcreteBuilder2----具体建造者类

public class Client { public static void main(String[] args) { VehicleBuilder vehicleBuilder = new SedanBuilder(); Director director = new Director(vehicleBuilder); director.assembleCar(); Vehicle vehicle = vehicleBuilder.getVehicle(); vehicle.show(); }}

代码如下:

客户端代码,客户端不需知道具体的建造过程。

public class Director { private VehicleBuilder vehicleBuilder; public Director(VehicleBuilder vehicleBuilder) { this.vehicleBuilder = vehicleBuilder; } public void assembleCar() { vehicleBuilder.buildEngine(); vehicleBuilder.buildWheel(); }}

澳门新濠3559 13

    public class ConcreteBuilder2 : Builder
    {
        private Product product = new Product();

        public override void BuildPartA()
        {
            product.Add("部件X");
        }

        public override void BuildPartB()
        {
            product.Add("部件Y");
        }

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

运行结果:one enginefour wheel

类关系图如下:

Builder是为创建一个Product对象的各个部件指定的抽象接口。

优点:建造者模式使得建造代码与表示代码分离,由于建造者隐藏了该产品是如何组装的,所以若需要改变一个产品的内部表示,只需要再定义一个具体建造者就可以了。建造者模式将一个复杂对象的生成责任进行了很好的分配。它把构造过程放到指挥者的方法中,把装配过程放到具体建造者类中。建造者模式的产品之间都有共通点。

 首先来看一下产品类

  • 指挥者

②  构造的过程允许构造对象有不同的表现。

    public class ConcreteBuilder1 : 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;
        }
    }

建造者模式主要涉及4个部分:

车间装配车辆是分步骤完成的复杂装配过程,车行采用不同的车间装配出不同的车辆。但是每个车辆装配的过程是稳定的,不同是会根据不同的需求装配出不同的车辆。因此可以将该问的处理采用生成器模式来解决。

建造者模式的好处就是使得建造代码与表示代码分离,由于建造者隐藏了该产品是如何组装的, 所以若需要改变一个产品的内部表示,只需要再定义一个具体的建造着就可以了。

澳门新濠3559 14澳门新濠3559 15

 主要是用于创建一些复杂的对象,这些对象内部构建间的建造顺序通常是稳定的, 但对象内部的构建通常是稳定的, 但对象内部的构建通常面临着复杂的变化。

Director---指挥者类

ConcreteBuilder1---具体建造者类

前言

    public abstract class Builder
    {
        public abstract void BuildPartA();
        public abstract void BuildPartB();
        public abstract Product GetResult();
    }

编辑:编程 本文来源:如果需要修改产品的内部表示澳门新濠3559,一步

关键词: 澳门新濠3559