设计模式学习笔记(六)——Prototype原型模式

转载 2007年09月18日 15:22:00
设计模式学习笔记(六)——Prototype原型模式

       Prototype原型模式是一种创建型设计模式,它主要面对的问题是:“某些结构复杂的对象”的创建工作;由于需求的变化,这些对象经常面临着剧烈的变化,但是他们却拥有比较稳定一致的接口。感觉好像和前几篇所说的设计模式有点分不清,下面我们先来回顾一下以前的几种设计模式,予以区分,再来说说原型模式。

       Singleton单件模式解决的问题是:实体对象个数问题(这个现在还不太容易混)

       AbstractFactory抽象工厂模式解决的问题是:“一系列互相依赖的对象”的创建工作

       Builder生成器模式解决的问题是:“一些复杂对象”的创建工作,子对象变化较频繁,对算法相对稳定

      FactoryMethor工厂方法模式解决的问题是:某个对象的创建工作

      再回来看看今天的Prototype原型模式,它是用来解决“某些结构复杂的对象”的创建工作。现在看看,好象还是差不多。这个问题先放在这,我们先往下看Prototype原型模式。

      《设计模式》中说道:使用原型实例指定创建对象的种类,然后通过拷贝这些原型来创建新的对象。

      此时注意:原型模式是通过拷贝自身来创建新的对象,这一点和其他创建型模式不相同。好,我们再来看看原型模式的结构


      
这个结构说明原型模式的客户端程序(ClientApp)是依赖于抽象(Prototype),而对象的具体实现也是依赖于抽象(Prototype)。符合设计模式原则中的依赖倒置原则——抽象不应依赖于具体实现,具体实现应依赖于抽象。

       我们现在回来看看原型模式的实现,我定义了一个场景,一个人开这一辆车在一条公路上。现在这件事是确定的,但不确定的有几点:1、人:姓名,性别,年龄;2车:什么牌子的;3公路:公路名字,长度,类型(柏油还是土路)。现在我们一个个实现。

       先来实现人,定义一个抽象类,AbstractDriver,具体实现男性(Man)和女性(Women

public abstract class AbstractDriver

    {

        public AbstractDriver()

        {

            //

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

            //

        }

 

        public string name;

        public string sex;

        public int age;

 

        public abstract string drive();

 

        public abstract AbstractDriver Clone();

    }

 

    public class Man:AbstractDriver

    {

        public Man(string strName,int intAge)

        {

            sex = "Male";

            name = strName;

            age = intAge;

        }

 

        public override string drive()

        {

            return name + " is drive";

        }

 

        public override AbstractDriver Clone()

        {

            return (AbstractDriver)this.MemberwiseClone();

        }

    }

 

    public class Women:AbstractDriver

    {

        public Women(string strName,int intAge)

        {

            sex = "Female";

            name = strName;

            age = intAge;

        }

 

        public override string drive()

        {

            return name + " is drive";

        }

 

        public override AbstractDriver Clone()

        {

            return (AbstractDriver)this.MemberwiseClone();

        }

    }

    注意:抽象代码中有一个Clone的方法,个人认为这个方法是原型模式的一个基础,因为前面讲了原型模式是通过拷贝自身来创建新的对象。

      下面我们再来实现公路和汽车

      公路:

public abstract class AbstractRoad

    {

        public AbstractRoad()

        {

            //

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

            //

        }

 

        public string Type;

        public string RoadName;

        public int RoadLong;

 

        public abstract AbstractRoad Clone();

    }

 

    public class Bituminous:AbstractRoad    //柏油路

    {

        public Bituminous(string strName,int intLong)

        {

            RoadName = strName;

            RoadLong = intLong;

            Type = "Bituminous";

        }

 

        public override AbstractRoad Clone()

        {

            return (AbstractRoad)this.MemberwiseClone();

        }

    }

 

    public class Cement:AbstractRoad        //水泥路

    {

        public Cement(string strName,int intLong)

        {

            RoadName = strName;

            RoadLong = intLong;

            Type = "Cement";

        }

 

        public override AbstractRoad Clone()

        {

            return (AbstractRoad)this.MemberwiseClone();

        }

    }

   

    汽车:

    public abstract class AbstractCar

    {

        public AbstractCar()

        {

            //

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

            //

        }

 

        public string OilBox;

        public string Wheel;

        public string Body;

 

        public abstract string Run();

        public abstract string Stop();

 

        public abstract AbstractCar Clone();

    }

 

    public class BMWCar:AbstractCar

    {

        public BMWCar()

        {

            OilBox = "BMW's OilBox";

            Wheel = "BMW's Wheel";

            Body = "BMW's body";

        }

 

        public override string Run()

        {

            return "BMW is running";

        }

 

        public override string Stop()

        {

            return "BMW is stoped";

        }

 

        public override AbstractCar Clone()

        {

            return (AbstractCar)this.MemberwiseClone();

        }

    }

 

    public class BORACar:AbstractCar

    {

        public BORACar()

        {

            OilBox = "BORA's OilBox";

            Wheel = "BORA's Wheel";

            Body = "BORA's Body";

        }

 

        public override string Run()

        {

            return "BORA is running";

        }

 

        public override string Stop()

        {

            return "BORA is stoped";

        }

 

        public override AbstractCar Clone()

        {

            return (AbstractCar)this.MemberwiseClone();

        }

    }

 

    public class VolvoCar:AbstractCar

    {

        public VolvoCar()

        {

            OilBox = "Volvo's OilBox";

            Wheel = "Volvo's Wheel";

            Body = "Volvo's Body";

        }

 

        public override string Run()

        {

            return "Volvo is running";

        }

 

        public override string Stop()

        {

            return "Volvo is stoped";

        }

 

        public override AbstractCar Clone()

        {

            return (AbstractCar)this.MemberwiseClone();

        }

    }

    然后我们再来看看场景,我们定义一个Manage类,在这个场景中有一个人,一辆车和一条公路,代码实现如下:

class Manage

    {

        public AbstractCar Car;

        public AbstractDriver Driver;

        public AbstractRoad Road;

 

        public void Run(AbstractCar car,AbstractDriver driver,AbstractRoad road)

        {

            Car = car.Clone();

            Driver = driver.Clone();

            Road = road.Clone();

        }

    }

    可以看到,在这个代码中,场景只是依赖于那几个抽象的类来实现的。最后我们再来实现一下客户代码,比如我现在要一辆Volvo车,一个叫“Anli”的女司机,在一条叫“Road1长1000的柏油路上。

        static void Main(string[] args)

        {

            Manage game = new Manage();

            game.Run(new VolvoCar(),new Women("Anli",18),new Bituminous("Road1",1000));

            Console.Write("CarRun:" + game.Car.Run() + "/n");

            Console.Write("DriverName:" + game.Driver.name + "/n");

            Console.Write("DriverSex:" + game.Driver.sex + "/n");

            Console.Write("RoadName:" + game.Road.RoadName + "/n");

            Console.Write("RoadType:" + game.Road.Type + "/n");

            Console.Write("CarStop:" + game.Car.Stop() + "/n");

            Console.Read();

        }

    运行的结果是:

    CarRun:Volvo is running

DriverName:Anli

DriverSex:Female

RoadName:Road1

RoadType:Bituminous

CarStop:Volvo is stoped

 

如果我现在想换成BORA车,让我(kid-li)开,在一个水泥马路上,我们只要更改Main函数中Run的实参。

game.Run(new BORACar(),new Man("kid-li",24),new Cement("Road1",1000));

运行结果是:

CarRun:BORA is running

DriverName:kid-li

DriverSex:Male

RoadName:Road1

RoadType:Cement

CarStop:BORA is stoped

这样,经过简单的更改,可以实现实现细节的变化。

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

1Prototype模式同样用于隔离类对象的使用者和具体类型(易变类)之间的耦合关系,它同样要求这些“易变类”拥有“稳定的接口”。

2Prototype模式对于“如何创建易变类的实体对象”采用“原型克隆”的方法来实现,它使得我们可以非常灵活地动态创建“拥有某些稳定接口”的新对象——所需工作仅仅是注册一个新类的对象(即原型),然后在任何需要的地方不断地Clone

3Prototype模式中的Clone方法可以利用Object类的MemberwiseClone()或者序列化来实现深拷贝。

这里面我们再来说说浅拷贝和深拷贝。我想对于Prototype模式是很重要的。我觉得浅拷贝和深拷贝的关键区别是对于引用对象的拷贝。例如我们有一个类Class1

public class Class1

{

    int a;

    int[] b;

}

我们用浅拷贝实现了两个对象c1c2,对于c1.ac2.a,他们所有的内存空间是不一样的,但是c1.bc2.b,由于它们是引用类型,在浅拷贝时只是拷贝了一个地址给b成员,实际上c1.bc2.b指向同一块内存。

但如果我们用深拷贝,c1.bc2.b指向的是不同的内存地址。那又如何实现深拷贝呢?我们可以利用序列化和反序列化来实现。

对于浅拷贝和深考贝的问题,我的同事TerryLee曾写过一篇文章《小议.NET中的对象拷贝》,我在这就不赘述了。

 

设计模式深入学习---Prototype原型模式

今天我们继续来聊下Prototype原型模式。这篇应该是关于工厂设计模式的最后一篇。下次就往内部讲解结构类型的设计模式。首先我们说下Prototype原型模式的用法。Prototype原型模式主要是用...

C++设计模式-Prototype原型模式

作用: 用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。 Prototype模式提供了一个通过已存在对象进行新对象创建的接口(Clone), Clone()实现和具体的语言...

面向对象设计模式之Prototype原型模式(创建型)

意图:使用原型实例指定创建对象的种类,然后通过拷贝这些原型来创建新的对象 可适用性: 当要实例化的类是在运行时刻指定时,例如,通过动态装载;或者 为了避免创建一个与产品类层次平行的工厂类层次时...
  • yja886
  • yja886
  • 2012年02月24日 10:14
  • 575

C++设计模式-Prototype原型模式

作用: 用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。 Prototype模式提供了一个通过已存在对象进行新对象创建的接口(Clone), Clone()实现和具体的语言...

[设计模式]Prototype原型模式

prototype原型模式 用原型实例指定创建对象的种类,并且通过拷贝这个原型来创建新的对象。    小demo prototype.h #ifndef PROTOTYPE_H #define PR...

设计模式(4) - Prototype原型模式

1. 意图    原型模式可以让我们在创建新的实例时,隐藏内部复杂性。    用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。Prototype模式提供了一个通过已存在对象进行新对象创...
  • shltsh
  • shltsh
  • 2013年12月22日 00:05
  • 598

设计模式-prototype原型模式

有的时候,我们需要一个实例时,并且,当创建一个实例的过程比较复杂或者说是昂贵时, 比如,创建实例的构造函数非常的复杂,在执行这个构造函数时会消耗较长的时间, 同时呢,这个构造函数中的一些信息又没有...

C++设计模式之九--Prototype原型模式

转自:http://www.cnblogs.com/jiese/archive/2013/07/01/3164428.html  作用: 用原型实例指定创建对象的种类,...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:设计模式学习笔记(六)——Prototype原型模式
举报原因:
原因补充:

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