设计模式学习笔记(四)——Builder生成器模式

原创 2007年09月18日 13:00:00
设计模式学习笔记(四)——Builder生成器模式
 

       Builder生成器模式是一种创建型模式,它主要是应对项目中一些复杂对象的创建工作。所谓“复杂对象”,是只:此对象中还含有其它的子对象。Builder模式所面对的情况是:各个部分的子对象用一定的算法构成;由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将他们组合在一起的算法却相对稳定。简单的说:子对象变化较频繁,对算法相对稳定。

       这是解决一个复杂对象的创建工作,现在变化的部分和相对稳定的部分已经明确,我们要做的是隔离变化,如何将子对象和算法隔离是要解决的问题。

       《设计模式》中说道:将一个复杂对象的构建与其表示向分离,使得同样的构建过程可以创建不同的表示。

       我们现在定义一个场景:还是选择汽车,BMWBORA。试想一下,如果我们用较为普通的写法可以写成如下代码:

public static void Main()

        {

            Car car = new Car();

            Console.Write("Wheel:" + car._wheel + "/n");

            Console.Write("OilBox:" + car._oilBox + "/n");

            Console.Write("Body:" + car._body + "/n");

            Console.Read();

        }

 

        public class Car

        {

            public string _wheel = BMWWheel;

            public string _oilbox = BMWOilBox;

            public string _body = BMWBody;

}

当我们不确定或因需求变化而改变对汽车品牌的选择时,我们也许会频繁的更改Car类中的实现。

现在我们用Manager来管理汽车的构建。当然是构建一个抽象的类对象(对象如下图的builder,抽象类为AbstractBuilder,对于BMWBORA的构建类型继承AbstractBuilder

 


首先我们先来编写
AbstractBuilder抽象类的实现,代码如下:

public abstract class AbstractBuilder

    {

        public string _wheel;

        public string _oilBox;

        public string _body;

        public abstract void BuildWheel();

        public abstract void BuildOilBox();

        public abstract void BuildBody();

 

        public abstract Car GetCar();  

    }

 

    public abstract class Car

    {

    }

然后我们再来实现BMWBORA的构建,也就是Builder模式中频繁变化的部分,他们都要继承AbstractBuilder

BMW

public class BMWBuilder:AbstractBuilder

    {

        public BMWBuilder()

        {

            //

            // TODO: 在此处添加构造函数逻辑

            //

        }

 

        public override void BuildWheel()

        {

            _wheel = "BMWWheel";

        }

 

        public override void BuildOilBox()

        {

            _oilBox = "BMWOilBox";

        }

 

        public override void BuildBody()

        {

            _body = "BMWBody";

        }

 

        public override Car GetCar()

        {

            return new BMWCar();

        }

 

    }

 

    public class BMWCar:Car

    {}

BORA

public class BORABuilder:AbstractBuilder

    {

        public BORABuilder()

        {

            //

            // TODO: 在此处添加构造函数逻辑

            //

        }

 

        public override void BuildWheel()

        {

            _wheel = "BORAWheel";

        }

 

        public override void BuildOilBox()

        {

            _oilBox = "BORAOilBox";

        }

 

        public override void BuildBody()

        {

            _body = "BORABody";

        }

 

        public override Car GetCar()

        {

            return new BORACar();

        }

    }

 

    public class BORACar:Car

    {}

现在我们使用一种Manager方法来管理汽车的构建,这也就是Builder模式中提到的相对稳定的算法,我用一个类来实现:

private class CarManager

        {

            public BuilderClass.Car CreateCar(BuilderClass.AbstractBuilder builder)

            {

                builder.BuildBody();

                builder.BuildOilBox();

                builder.BuildWheel();

 

                Console.Write("Wheel:" + builder._wheel + "/n");

                Console.Write("OilBox:" + builder._oilBox + "/n");

                Console.Write("Body:" + builder._body + "/n");

                Console.Read();

                return builder.GetCar();

            }

        }

现在我们可以在客户程序中调用这个Manager来构建Car

public static void Main()

        {

            CarManager manager = new CarManager();

            BuilderClass.Car car =

manager.CreateCar(new BuilderClass.BORABuilder());

        }

结果如下:

Wheel:BORAWheel

OilBox:BORAOilBox

Body:BORABody

如果我们现在要换成BMW,我们只要在Main()函数中改变manager.CreateCar中的参数就可以:

public static void Main()

        {

            CarManager manager = new CarManager();

            BuilderClass.Car car =  

manager.CreateCar(new BuilderClass.BMWBuilder());

        }

结果如下:

Wheel:BMWWheel

OilBox:BMWOilBox

Body:BMWBody

这样,经过简单的修改可以实现对不同Car的构建。如果我们还有其他汽车的实现只要将他的类继承AbstractBuilder,然后在Main()中修改就可以。说道这里,我想起了在第一篇中提到的设计模式中的“开---闭原则”,这个方式是很符合这个原则的,对代码进行了扩展,以减少了代码修改量。而且我们还有很多方法可以利用,如:WebConfig中的appSettings来动态的配置,从数据库中读取,或利用依赖方式动态生成。

现在我们再来看看Builder模式的几个要点:

Builder模式主要用于构建一个复杂的对象,但这个对象构建的算法是稳定的,对象中的各个部分经常变化。Builder模式主要在于应对复杂对象各个部分的频繁需求变动。但是难以应对算法的需求变动。这点一定要注意,如果用错了,会带来很多不必要的麻烦。

课程中还提到了.Net中的Builder模式的应用。如:Page类中的OnInit()等方法的实现。我们在写一个Web页面的时候。他的codebehind代码都是继承System.Web.UI.Page基类的。OnInit()函数是可以重写的

 
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

设计模式之--生成器(builder)模式(学习分析笔记)

分析原则:封装变化BUILDER(生成器)—对象创建型模式1. 意图将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。解读:1.从意图中已经可以比较明显的看出此模式的要点。“复...

设计模式学习笔记——建造者(Builder)模式

设计模式学习笔记——建造者(Builder)模式@(设计模式)[设计模式, 建造者模式, builder]设计模式学习笔记建造者Builder模式 基本介绍 建造者案例 类图 实现代码 Builder...

设计模式(2)—— 生成器 (Builder)

Builder解决的问题 Builder(生成器)的模式用于用多个部件生成不同产品的问题: Builder模式适用于: 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时 当构...

Builder设计模式学习笔记

建造模式是对象的创建模式。建造模式可以将一个产品的内部表象(internal representation)与产品的生产过程分割开来,从而可以使一个建造过程生成具有不同的内部表象的产品对象   有...

设计模式 笔记 生成器(建造者)模式 Builder

//---------------------------15/04/08---------------------------- //builder 生成器(建造者)模...

深入浅出设计模式(3)——生成器模式(Builder)

一、概述 在软件系统中,有时候面临着“一个复杂对象”的创建工作,其通常由各个部分的子对象用一定的算法构成;由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法确相对...

设计模式——生成器模式(Builder Pattern)

生成器模式:将一个复杂的对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。生成器模式的主要思想是抽象出创建对象的步骤,使得这些步骤的不同实现可以创建不同的对象表示。

设计模式深入学习-Builder生成器(创建型模式 )

假如我们在创建游戏中的一个房屋House设施,该房屋肯定会有好几个部分组成,而且各个部分都会经常发生改变。比如窗,门等设施需求经常发生变化,但房屋整体不变。比如换个屋顶,但我们整个房子其他东西不变。如...

java 设计模式学习笔记三 Builder模式

设计模式  builder 将一个复杂的对象构建与他的表示分离,使同样的构建过程可以创建不同的表示 把创建和部件的创建分别开来 示例代码:  /**  * 部件实体 ...

设计模式C++学习笔记之十(Builder建造者模式)

博文很精彩,为方便个人学习特转载,地址:http://www.cnblogs.com/wanggary/archive/2011/04/15/2017615.html 建造者模式,将一个复杂...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)