Prototype原型(创建型模式)

最新推荐文章于 2021-11-13 19:13:47 发布
最新推荐文章于 2021-11-13 19:13:47 发布
阅读量838 收藏
点赞数
分类专栏： 设计模式系列 文章标签： prototype string object system class file
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Helen_Chen/article/details/1536173
版权

依赖关系的倒置

抽象不应该依赖于实现细节，实现细节应该依赖于抽象。

动机：

在软件系统中，经常面临着“某些结构复杂的对象”的创建工作；由于需要的变化，这些对象经常面临剧烈的变化，但是他们却拥有比较稳定一致的接口。

如何应对这种变化？如何向“客户程序 (使用这些对象的程序) ”隔离出“这些易变对象”，从而使得“依赖这些易变对象的客户程序”不随着需求改变而改变？

意图：

使用原型实例指定创建对象的种类，然后通过拷贝这些原型来创建新的对象。

Prototype模式的几个要点：

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

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

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


StringTokenizer.cs代码示例：

using  System;

 namespace  CsharpPats
 {
    //String Tokenizer class
    public class StringTokenizer     {
        private string data, delimiter;
        private string[] tokens;
        private int index;
        public StringTokenizer(string dataLine)         {
            init(dataLine, " ");
                }
        private void init(String dataLine, string delim) {
            delimiter = delim;
            data = dataLine;
            tokens = data.Split (delimiter.ToCharArray() );
            index = 0;
        }
        public StringTokenizer(string dataLine, string delim) {
           init(dataLine, delim);    
        }
        public bool hasMoreElements() {
            return (index < (tokens.Length));
        }
        public string nextToken() {
            return nextElement();
        }
        public string nextElement() {
            string s = tokens[index++];
            while((s.Length <=0) && (index<tokens.Length ))
                s = tokens[index++];
        return s;
        }
    }
}
 

csFile.cs代码示例：

using  System;
 using  System.IO ;
 namespace  CsharpPats
 {
    /// <summary>
    /// A simple file handlng class
    /// </summary>
    public class csFile
    {
        private string fileName;
        StreamReader ts;
        StreamWriter ws;
        private bool opened, writeOpened;
        //-----------
        public csFile() {
            init();
        }
        //-----------
        private void init() {
            opened = false;
            writeOpened = false;
        }
        //-----------
        public csFile(string file_name)     {
            fileName = file_name;
            init();
        }
        //-----------
        public bool OpenForRead(string file_name){
            fileName = file_name;
            try {
                ts = new StreamReader (fileName);
                opened=true;
            }
            catch(FileNotFoundException ) {
                return false;
            }
            return true;
        }
        //-----------
        public bool OpenForRead() {
            return OpenForRead(fileName);
        }
        //-----------
        public string readLine() {
            return ts.ReadLine ();
        }
        //-----------
        public void writeLine(string s) {
            ws.WriteLine (s);
        }
        //-----------
        public void close() {
            if (opened)
                ts.Close ();
            if(writeOpened)
                ws.Close();
        }
        //-----------
        public bool OpenForWrite() {
            return OpenForWrite(fileName);
        }
        //-----------
        public bool OpenForWrite(string file_name) {
            try{
                ws = new StreamWriter (file_name);
                fileName = file_name;
                writeOpened = true;
                return true;
            }
            catch(FileNotFoundException ) {
                return false;
            }
        }
    }
}

Swimmer.cs代码示例：

using  System;
 using  CsharpPats;
 namespace  SimpleProto
 {
    /// <summary>
    /// Summary description for Swimmer.
    /// </summary>
    public class Swimmer:IComparable     {
        private string name;         //name
        private string lname, frname;//split names
        private int age;            //age
        private string club;        //club initials
        private float time;            //time achieved
        private bool female;        //sex
    //---------
        public Swimmer(string line) {
            StringTokenizer tok = new StringTokenizer(line,",");
            splitName(tok);
            age = Convert.ToInt32 (tok.nextToken());
            club = tok.nextToken();
            time = Convert.ToSingle (tok.nextToken());
            string sx = tok.nextToken().ToUpper ();
            female = sx.Equals ("F");
        }
        //---------
        private void splitName(StringTokenizer tok) {
            name = tok.nextToken();
            int i = name.IndexOf (" ");
            if(i >0 ) {
                frname = name.Substring (0, i);
                lname = name.Substring (i+1).Trim ();
            }
        }
        //---------
        public int CompareTo(object swo) {
            Swimmer sw = (Swimmer)swo;
            return lname.CompareTo (sw.getLName() );
        }
        //---------
        public bool isFemale() {
            return female;
        }
        //---------
        public int getAge() {
            return age;
        }
        //---------
        public float getTime() {
            return time;
        }
        //---------
        public string getName() {
            return name;
        }
        //---------
        public string getClub() {
            return club;
        }
        //---------
        public string getLName() {
            return lname;
        }
    }
}

SwimData.cs代码示例：

using  System;
 using  System.Collections ;
 using  CsharpPats;

 namespace  SimpleProto
 {
    /// <summary>
    /// Summary description for SwimData.
    /// </summary>
    public class SwimData:ICloneable     {
        protected ArrayList swdata;
        private int index;
        //-----
        public SwimData() {
                swdata = new ArrayList ();
        }
        //-----
        public SwimData(ArrayList swd) {
            swdata = swd;
            index=0;
        }
        //-----
        public int count() {
            return swdata.Count ;
        }
        //-----
        public SwimData(string filename)         {
            swdata = new ArrayList ();
            csFile fl = new csFile(filename);
            fl.OpenForRead ();
            string s = fl.readLine ();
            while(s != null) {
                Swimmer sw = new Swimmer(s);
                swdata.Add (sw);
                s = fl.readLine ();
            }
            fl.close ();
        }
        //-----
        public object Clone() {
            SwimData newsd = new SwimData(swdata);
            return newsd;
        }
        //-----
        public void moveFirst() {
            index = 0;
        }
        //-----
        public bool hasMoreElements() {
            return (index < swdata.Count-1 );
        }
        //-----
        public void sort() {
        //sort using IComparable interface of Swimmer
            swdata.Sort (0,swdata.Count ,null);
        }
        //-----
        public Swimmer getSwimmer() {
            if(index < swdata.Count )
                return (Swimmer)swdata[index++];
            else
                return null;
        }
    }
}

事件代码：

private   void  init()  {
            swdata = new SwimData ("swimmers.txt");
            reload();
        }

private   void  reload()  {
            lsKids.Items.Clear ();
            swdata.moveFirst ();
            while (swdata.hasMoreElements() ) {
                Swimmer sw = swdata.getSwimmer ();
                lsKids.Items.Add (sw.getName() );
            }
        
        }

private   void  btClone_Click( object  sender, System.EventArgs e)  {
            SwimData newSd = (SwimData)swdata.Clone ();        
            newSd.sort ();
            while(newSd.hasMoreElements() ) {
                Swimmer sw = (Swimmer)newSd.getSwimmer ();
                lsNewKids.Items.Add (sw.getName() );
            }
        }

private   void  btBack_Click( object  sender, System.EventArgs e)  {
            reload();
        }

使用原型模式

SexSwimData.cs代码示例：

using  System;
 using  System.Collections ;
 namespace  DeepSexClone
 {
    /// <summary>
    /// Summary description for SexSwimData.
    /// </summary>
    public class SexSwimData:SwimData
    {
        public SexSwimData() {
            
        }
        public SexSwimData(string filename):base(filename){}
        public SexSwimData(ArrayList ssd):base(ssd){}
        public void sort(bool isFemale) {
            ArrayList swd = new ArrayList();
            for (int i = 0; i < swdata.Count ; i++) {
                Swimmer sw =(Swimmer)swdata[i];
                if (isFemale == sw.isFemale() ) {
                    swd.Add (sw);
                }
            }
            swdata = swd;
        }
        
    }
}

Swimmer.cs代码示例：

using  System;
 using  CsharpPats;
 namespace  DeepSexClone
 {
    /// <summary>
    /// Summary description for Swimmer.
    /// </summary>
    public class Swimmer:IComparable     {
        private string name;         //name
        private string lname, frname;//split names
        private int age;            //age
        private string club;        //club initials
        private float time;            //time achieved
        private bool female;        //sex
    //---------
        public Swimmer(string line) {
            StringTokenizer tok = new StringTokenizer(line,",");
            splitName(tok);
            age = Convert.ToInt32 (tok.nextToken());
            club = tok.nextToken();
            time = Convert.ToSingle (tok.nextToken());
            string sx = tok.nextToken().ToUpper ().Trim ();
            female = sx.Equals ("F");
        }
        //---------
        private void splitName(StringTokenizer tok) {
            name = tok.nextToken();
            int i = name.IndexOf (" ");
            if (i > 0 ) {
                frname = name.Substring (0, i);
                lname = name.Substring (i + 1).Trim ();
            }
        }
        //---------
        public int CompareTo(object swo) {
            Swimmer sw = (Swimmer)swo;
            return lname.CompareTo (sw.getLName() );
        }
        //---------
        public bool isFemale() {
            return female;
        }
        //---------
        public int getAge() {
            return age;
        }
        //---------
        public float getTime() {
            return time;
        }
        //---------
        public string getName() {
            return name;
        }
        //---------
        public string getClub() {
            return club;
        }
        //---------
        public string getLName() {
            return lname;
        }
    }
}

SwimData.cs代码示例：

using  System;
 using  System.Collections ;
 using  CsharpPats;

 namespace  DeepSexClone
 {
    /// <summary>
    /// Summary description for SwimData.
    /// </summary>
    public class SwimData    {
        protected ArrayList swdata;
        private int index;
        //-----
        public SwimData() {
                swdata = new ArrayList ();
        }
        //-----
        public SwimData(ArrayList swd) {
            swdata = swd;
            index=0;
        }
        //-----
        public void cloneMe(SwimData swdat) {
            swdata = new ArrayList ();
            ArrayList swd=swdat.getData ();
            //copy in swimmer objects
            for(int i=0; i < swd.Count ; i++) 
                swdata.Add (swd[i]);
        
        }
        //-----
        public int count() {
            return swdata.Count ;
        }
        //-----
        public SwimData(string filename)         {
            swdata = new ArrayList ();
            csFile fl = new csFile(filename);
            fl.OpenForRead ();
            string s = fl.readLine ();
            while(s != null) {
                Swimmer sw = new Swimmer(s);
                swdata.Add (sw);
                s = fl.readLine ();
            }
            fl.close ();
        }
        //-----
        public ArrayList getData() {
            return swdata;
        }
        //-----
        public void moveFirst() {
            index = 0;
        }
        //-----
        public bool hasMoreElements() {
            return (index < swdata.Count-1 );
        }
        //-----
        public void sort() {
        //sort using IComparable interface of Swimmer
            swdata.Sort (0, swdata.Count , null);
        }
        //-----
        public Swimmer getSwimmer() {
            if(index < swdata.Count )
                return (Swimmer)swdata[index++];
            else
                return null;
        }
    }
}

事件代码：

private   void  init()  {
            swdata = new SexSwimData ("swimmers.txt");
            reload();
        }

private   void  reload()  {
            lsKids.Items.Clear ();
            swdata.moveFirst ();
            while (swdata.hasMoreElements() ) {
                Swimmer sw = swdata.getSwimmer ();
                lsKids.Items.Add (sw.getName() );
            }
        

private   void  btClone_Click( object  sender, System.EventArgs e)  {
            SexSwimData newSd = new SexSwimData ();        
            newSd.cloneMe (swdata);
            newSd.sort (opFemale.Checked );
            lsNewKids.Items.Clear() ;
            while(newSd.hasMoreElements() ) {
                Swimmer sw = (Swimmer)newSd.getSwimmer ();
                lsNewKids.Items.Add (sw.getName() );
            }
        }

private   void  btBack_Click( object  sender, System.EventArgs e)  {
            reload();
        }

具有相同接口的不同类

AgeSwimData.cs代码示例：

using  System;
 using  System.Collections ;
 namespace  DeepSexClone
 {
    /// <summary>
    /// Summary description for SexSwimData.
    /// </summary>
    public class AgeSwimData:SwimData
    {
        ArrayList swd;
        public AgeSwimData() {
            swdata = new ArrayList ();
        }
        //------
        public AgeSwimData(string filename):base(filename){}
        public AgeSwimData(ArrayList ssd):base(ssd){}
        //------
        public override void cloneMe(SwimData swdat) {
            swd = swdat.getData ();
        }
        //------
        public override void sort() {
            Swimmer[] sws = new Swimmer[swd.Count ];
            //copy in swimmer objects
            for(int i=0; i < swd.Count ; i++) {
                sws[i] = (Swimmer)swd[i];
            }
            //sort into increasing order
            for( int i=0; i< sws.Length ; i++) {
                for (int j = i; j< sws.Length ; j++) {
                    if (sws[i].getAge ()>sws[j].getAge ()) {
                        Swimmer sw = sws[i];
                        sws[i]=sws[j];
                        sws[j]=sw;
                    }
                }
            }
            int age = sws[0].getAge ();
            int agecount = 0;
             int k = 0;
            swdata = new ArrayList ();
            bool quit = false;
            
            while( k < sws.Length && ! quit ) {
                while(sws[k].getAge() ==age && ! quit) {
                    agecount++;
                    if(k < sws.Length -1)
                        k++;
                    else
                        quit= true;
                }
                //create a new Swimmer with a series of X's for a name
                //for each new age
                string name = "";
                for(int j = 0; j < agecount; j++)
                    name +="X";
                Swimmer sw = new Swimmer(age.ToString() + " " +
                    name + "," + age.ToString() + ",club,0,F");
                swdata.Add (sw);
                agecount = 0;
                if(quit)
                    age = 0;
                else
                    age = sws[k].getAge ();
            }
        
        }
    }
}

用原型模式能根据需要克隆类，这样，在运行时就可以添加或删除类。根据程序运行情况，可以在运行时更改一个类的内部数据表示，也可以在运行时指定新对象而无需创建一个新类。

用C#实施原型模式的困难在于：如果类早已存在，则不能改变它们来增加需要的克隆方法。另外，间接引用其他类的列也不能被真正克隆。

拷贝原型类的想法意味着，你对类中的数据或方法有足够的访问权，这样在克隆之后可以修改它们。这可能需要向原型类中添加数据访问方法，这样在克隆了该类后，就能修改数据。

Helen_Chen
关注
专栏目录
C#设计模式之6——原型模式
Work Hard, Play Harder!
02-20 3100
一般情况下，目标类克隆原型中的数据，然后加以改造利用构造自己可以利用的数据。 目标类通过克隆一个或多个原型类来构造，然后再修改或者是填充克隆出来的类的细节以使得其行为符合预先期望。 原型模式一般设计对父类数据的克隆问题。   一般情况下，如果一个类包含一个数组成员，并且这个类实现了ICloneable接口，那么这个类就可以使用Clone()方法来进行克隆，但是克隆是否符合我们的要求就不一定了
deepfakes视频的网站_Dealing with Deepfake Videos 应对“深度伪造”视频
热门推荐
weixin_39945475的博客
12-22 2万+
total control of 完全控制candid adj.坦率的；直白的To be candid , I can't stand her . 说实话，我受不了她。audience n.观众；听众vacantly adv.神情茫然地on closer inspection 仔细一看；定睛一看it turned out 原来...couterfeit n.赝品，仿冒品...
Deep Sx
weixin_34195546的博客
09-01 783
Deep Sx which is indicated by slp_sus#.after enable this fuction will meet the EUP requested. 转载于:https://blog.51cto.com/13143423/1961996
java数据结构单链表的基本操作
sticker_start_tag的博客
12-14 1597
实验目的 1、掌握线性链表的操作特点，即指针是逻辑关系的映像。 2、掌握动态产生单链表的方法。 3、熟练掌握单链表的插入、删除操作特点，即指针赋值的先后次序。 4、熟练掌握单链表的取元素操作 实验内容 1、定义单链表类型并动态创建单链表； 2、实现单链表的取元素操作、插入操作和删除操作； 3、实现输出单链表中各元素值的操作； 4、将单链表中的最小元素移到最前面。 实验步骤 1、定义单链表节点类； ...
JS中定义对象方式四： 使用原型（prototype）方式创建对象之一
Geek_ymv的专栏
03-13 2879
function Person() {} Person.prototype.username = "zhangsan"; Person.prototype.password = "0123"; Person.prototype.getInfo = function() { alert(this.username + ":" + this.password)
创建型模式——原型模式（Prototype）
Pinkgranite86的博客
11-13 831
传送门（参考资料）： 1. GoF设计模式——C语言中文网 2. 廖雪峰学Java——设计模式 3. Java浅拷贝与深拷贝的实现方式 目录1. 原型模式简介2. 原型模式的优势与缺点3. 应用场景4. 原型模式的结构5. 原型模式的实现6. 模型的扩展7. 补充知识7.1 Java的浅拷贝与深拷贝7.2 原型模式会破坏单例模式吗？ 1. 原型模式简介 原型模式：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象 生活中原型模式的例子：文件的复制与拷贝，3D打印 程序中原型
Prototype （原型）模式
矢落叶の博客
05-25 2410
6.1 Prototype 模式   通常，我们使用 new 方式来生成类的实例。   new Something();   像这样 new 的方式来生成实例时，是必须指定类名的。但是，有时也需要 “不指定类名的前提下生成实例” 的需求。   （1） 对象种类繁多，无法将他们整合到一个类中时   此时需要要编写多个类文件来处理。   （2） 难以根据类生成实例时   生成实例的过程太过复杂，很难根...
PHP设计模式（四）原型模式Prototype实例详解【创建型】
10-15
原型模式（Prototype Pattern）属于创建型设计模式的一种，它允许我们创建具有相同特性的对象，而不必直接通过构造函数来实例化对象。原型模式在PHP中主要通过clone关键字来实现，当我们需要一个与某个已存在对象...
Java设计模式之Prototype原型模式
08-27
Prototype原型模式是Java设计模式中的一种创建型模式，它主要用于对象的克隆和创建。该模式的主要思想是将一个对象作为原型，然后通过克隆该对象来创建新的对象，从而实现对象的创建。 Prototype原型模式的优点是...
设计模式 创建型模式 Prototype模式(原型)
01-29
Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。...
[创建型模式]设计模之原型模式(Prototype Pattern)
08-13
**原型模式(Prototype Pattern)**是一种创建型设计模式，它允许我们通过复制现有的对象来创建新对象，而不是通过构造函数或工厂方法。这种模式的核心在于，它提供了一种更高效、更灵活的方式来创建新实例，特别是在...
Java---覆盖与多态(二)
weixin_44450793的博客
03-12 118
多态的基础语法: 举例 Animal.java //动物类: 父类 public class Animal { //移动的方法 public void move(){ System.out.println("动物在移动"); } } Dog.java //狗类: 子类 public class Dog extends Animal{ //移动的方法(覆盖) public void ...
TypeScript学习（三）ts中的类
qq_42584511的博客
06-08 1064
TypeScript学习（三）ts中的类 类 1.es5的类 1.1构造函数 只有属性 function Person(){ this.name="张三", this.age=20 } var p=new Person() console.log(p.name)//张三 属性和方法 function Person(){ this.name="张三"; this.age=20; this.run=function(){ console.log(this
Bridge桥接(结构型模式)
程序人生
03-23 969
抽象与实现抽象不应该依赖于实现细节，实现细节应该依赖于抽象。 动机：事实上由于Tank类型的固有逻辑，使得Tank类型具有了两个变化的维度——一个变化的维度为“平台的变化”，一个变化的维度为“型号的变化”。如何应对这种“多维度的变化”？如何利用面向对象技术来使得Tank类型可以轻松地沿着“平台”和“型号”两个方向变化，而不引入额外的复杂度？意图：将抽象部分与实现部分分离
Singleton单件(创建型模式)
程序人生
03-19 857
动机：在软件系统中，经常有这样一些特殊的类，必须保证它们在系统中只存在一个实例，才能确保它们的逻辑正确性、以及良好的效率。意图：可以保证一个类有且只有一个实例，并提供一个访问它的全局访问点。单线程Singleton模式的几个要点l         Singleton模式中的实例构造器可以设置为protected以允许子类派生。l         Singleton模式一般不要支
Factory Method工厂方法(创建型模式)
程序人生
03-21 783
从耦合关系谈起耦合关系直接决定着软件面对变化时的行为l         模块与模块之间的紧耦合使得软件面对变化时，相关的模块都要随之更改。l         模块与模块之间的松耦合使得软件面对变化时，一些模块更容易被替换或者更改，但其他模块保持不变。 动机：在软件系统中，经常面临着“某个对象”的创建工作；由于需求的变化，这个对象经常面临着剧烈的变化，但是它却拥有比较稳定的接
Builder生成器(创建型模式)
程序人生
03-20 776
l         假设创建游戏中的一个房屋House设施，该房屋的构建由几个部分组成，且各个部分要富于变化。l         如果使用最直观的设计方法，每一个房屋部分的变化，都将导致房屋构建的重新修正…… 动机：在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组
Abstract Factory抽象工厂(创建型模式)
程序人生
03-20 703
new的问题常规的对象创建方法：//创建一个Road对象Road road = new Road(); new的问题：实现依赖，不能应对“具体实例化类型”的变化。解决思路：封装变化点——哪里变化，封装哪里。潜台词：如果没有变化，当然不需要额外的封装！ 工厂模式的缘起l         变化点在“对象创建”，因此就封装“对象创建”；l     
PHP原型模式Prototype深度解析
"本文详细介绍了PHP中的原型模式(Prototype)，这是一种创建型设计模式，通过复制已有对象来创建新对象，避免了复杂的构造过程。文中通过实例展示了如何在PHP中实现原型模式，并阐述了其适用场景和优点。" PHP设计...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值