原型模式

 

     首先看看简历代码初步实现的代码:

    

<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;"><SPAN style="FONT-SIZE: 18px">//简历类   
    class Resume
    {  
        private string name;  
        private string sex;  
        private string age;  
        private string timeArea;  
        private string company;  
  
        public Resume(string name)  
        {  
            this.name = name;  
        }  
  
        //设置个人信息   
        public void SetPersonalInfo(string sex, string age)  
        {  
            this.sex = sex;  
            this.age = age;  
        }  
  
        //设置工作经历   
        public void SetWorkExperience(string timeArea, string company)  
        {  
            this.timeArea = timeArea;  
            this.company = company;  
  
        }  
  
        //显示   
        public void Display()  
        {  
            Console.WriteLine("{0}{1}{2}", name, sex, age);               
              
              Console.WriteLine("工作经历:{0}{1}", timeArea, company);  
        }  
  
       
    }</SPAN></span></span>
<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;"><span style="font-size:18px;">下面看看客户端调用代码:</span></span></span>
<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;"><SPAN style="FONT-SIZE: 18px"> class Program  
    {  
        static void Main(string[] args)  
        {  
            Resume a = new Resume("大鸟");  
            a.SetPersonalInfo("男", "29");  
            a.SetWorkExperience("1998-2000","XX公司");  
  
             
            Resume b = (Resume)a.Clone();  
            b.SetWorkExperience("1998-2000", "XX公司");  
  
            Resume c = (Resume)a.Clone();  
            c.SetPersonalInfo("男", "24");  
            c.SetWorkExperience("1998-2000","XX公司");   
  
            a.Display();  
            b.Display();  
            c.Display();  
  
            Console.Read(); 
 
        }  
    }</SPAN>   

        }
    }
    </span></span>

           运行结果内存图,如下:

      不足:上面三份简历需要实例化三次,客户端代码多,当简历达到20份甚至上百份时,可想而知,客户端就不能看,内容也是被大量的消耗掉。

      下面是改进客户端代码后的结果,改进后的客户端代码如下:

<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;"><SPAN style="FONT-SIZE: 18px"> class Program  
    {  
        static void Main(string[] args)  
        {  
            Resume a = new Resume("大鸟");  
            a.SetPersonalInfo("男", "29");  
            a.SetWorkExperience("1998-2000","XX公司");  
  
            
            Resume b = a;  
              
            Resume c = a;  
              
            a.Display();  
            b.Display();  
            c.Display();  
  
            Console.Read(); 
 
        }  
    }</SPAN>  </span></span>


     运行结果内存图,如下:

       优点;上面的Resume b=a;其实就是传引用,而不是传值,这样做就如同在b纸张上写者简历在a处一样,没有实际的内容的,这样做大量的节省了内存的空间,但是上面适用于字段的值完全相同的情况,当a,b,c要求某些字段有区别时,传引用就不能达到要求了。

      提到这里,我们就要提到一个设计模式了------原型设计模式

      这里对原型模式进行一下简单的介绍:

      原型模式:用原型实例创建对象的种类,并且通过拷贝这些原型创建新的对象。



       基本原型模式的实现代码

<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;"><SPAN style="FONT-SIZE: 18px">namespace 原型模式  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
              
  
            ConcretePrototype1 p1 = new ConcretePrototype1("I");  
  
            //克隆类ConcretePrototype1的对象p1就能得到新的实例c1   
            ConcretePrototype1 c1 = (ConcretePrototype1)p1.Clone();  
            Console.WriteLine("Cloned:{0}", c1.Id);  
  
            Console.Read();  
        }  
    }  
  
      
    //原型类   
    abstract class Prototype   
    {  
        private string id;  
        public Prototype(string id)  
        {  
            this.id = id;  
        }  
        public string Id  
        {  
            get { return id; }  
        }  
  
        //在抽象类中声明一个克隆的方法   
        public abstract Prototype Clone();  
    }  
  
      
    //具体原型类   
    class ConcretePrototype1 : Prototype   
    {  
        public ConcretePrototype1(string id)  
            : base(id)  
        { }  
  
        public override Prototype Clone()  
        {  
            //创建当前对象的浅副表本   
            return (Prototype)this.MemberwiseClone();  
        }  
  
    }  
  
     
}</SPAN>  
</span></span>


        MemberwiseClone()方法是创建一个新对象,然后将当前对象的非静态字段复制到该新对象。如果字段是值类型的,则对该字段执行逐位复制。如果字段是引用类型,则复制引用但不复制引用的对象;因此,原始对象及其副本引用同一对象。

        对上面的简历应用原型模式之后,代码如下:

       例如,复制一份简历,简历的原型实现


       实现如下:

<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;">//简历类
    class Resume:ICloneable  
    {
        private string name;
        private string sex;
        private string age;
        private string timeArea;
        private string company;

        public Resume(string name)
        {
            this.name = name;
        }

        //设置个人信息
        public void SetPersonalInfo(string sex, string age)
        {
            this.sex = sex;
            this.age = age;
        }

        //设置工作经历
        public void SetWorkExperience(string timeArea, string company)
        {
            this.timeArea = timeArea;
            this.company = company;

        }

        //显示
        public void Display()
        {
            Console.WriteLine("{0}{1}{2}", name, sex, age);
            
            //实现接口的方法,用来克隆对象
            Console.WriteLine("工作经历:{0}{1}", timeArea, company);
        }

        public object Clone()
        {
            return (Object)this.MemberwiseClone();
        }
    }
</span></span>


         客户端实现代码如下:

<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;"><SPAN style="FONT-SIZE: 18px"> class Program  
    {  
        static void Main(string[] args)  
        {  
            Resume a = new Resume("大鸟");  
            a.SetPersonalInfo("男", "29");  
            a.SetWorkExperience("1998-2000","XX公司");  
  
             
            Resume b = (Resume)a.Clone();  
            b.SetWorkExperience("1998-2006", "YY企业");  
  
            Resume c = (Resume)a.Clone();  
            c.SetPersonalInfo("男", "24");  
               
              a.Display();  
            b.Display();  
            c.Display();  
  
            Console.Read();  
  
  
  
        }  
    }</SPAN>  
</span></span>

运行结果内存图如下:


      好处:客户端代码变得清晰了,当你想要修改某份简历,直接对这份简历修改就可以,不会影响到其他简历,相同的部分就不用再写代码了,只修改不同之处就可以。性能也提高了,因为每new一次,都需要执行一次构造函数,如果构造函数的执行时间很长,那么多次执行这个初始化操作就实在太低效率了。

      一般在初始化的信息不发生变化的情况下,克隆是最好的办法。这既隐藏了对象创建的细节,又对性能是大大的提升。 

    上面使用了MemberwiseClone()方法,其实就是应用了浅复制,但是上面的成员变量没有引用类型的,所以,看不出深复制于浅复制的区别。

    下面以引用类型为例,讲解深复制与浅复制的区别。

     将timeArea和company这两个成员变量从Resume这里类里抽出来,然后放到WorkExperienc这个类里,但是简历里又要包含某个人的工作经验,所以,就把timeArea和company这两个成员变量放在Resume里定义,成为引用类型的成员变量。

      浅复制: 被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。也就是说,浅复制仅仅复制所考虑的对象,而不复制它所引用的对象。

      我们先来看一个例子,简历复制。

     结构图



代码实现

<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;">工作经历类


 //工作经历
    class WorkExperience
    {
        private string workDate;
        public string WorkDate
        {
            get { return workDate; }
            set { workDate = value; }
        }

        private string company;
        public string Company 
        {
            get { return company; }
            set { company = value; }
        }

    }</span></span>


<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;">简历类 


  //简历类
    class Resume:ICloneable  
    {
        private string name;
        private string sex;
        private string age;

        //引用"工作经历"对象
        private WorkExperience work;


        public Resume(string name)
        {
            this.name = name;
            
            //在"简历"类实例化时同时实例化"工作经历"
            work = new WorkExperience();
        }

        //设置个人信息
        public void SetPersonalInfo(string sex, string age)
        {
            this.sex = sex;
            this.age = age;
        }

        //设置工作经历
        public void SetWorkExperience(string workDate, string company)
        {
            
            work.WorkDate = workDate;
            
            //调用此方法时,给对象的两个属性赋值
            work.Company = company;
            

        }

        //显示
        public void Display()
        {
            Console.WriteLine("{0}{1}{2}", name, sex, age);
            Console.WriteLine("工作经历:{0}{1}", work.WorkDate , work.Company);
        }

        public object Clone()
        {
            return (Object)this.MemberwiseClone();
        }
    }</span></span>

客户端调用代码

<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;">  class Program
    {
        static void Main(string[] args)
        {
            Resume a = new Resume("大鸟");
            a.SetPersonalInfo("男", "29");
            a.SetWorkExperience("1998-2000","XX公司");

           
            Resume b = (Resume)a.Clone();
            b.SetWorkExperience("1998-2006", "YY企业");

            Resume c = (Resume)a.Clone();
            c.SetPersonalInfo("男", "24");
            c.SetWorkExperience("1998-2003","ZZ企业"); 

            //b和c都克隆于a,但当它们都设置了“工作经历”时,我们希望的结果是三个的显示不一样
            a.Display();
            b.Display();
            c.Display();

            Console.Read();



        }
    }</span></span>

运行内存图如下:


      上面就是浅复制,被复制对象的所有变量都含有跟原来的对象相同的值,而所有的其他对象的引用都仍然指向原来的对象。

      比如上面的例子:work是引用类型的变量,在内存中work指向了内存中对象workExperience的一块区域,当a.clone()时,a对应的内存区域会被复制,但是其里面包含的work对应的一块区域不会被复制,只是复制work的指向(引用)。

深复制

       被复制对象的所有变量都含有与原来的对象相同的值,除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过得新对象,而不再是原有的那些被引用的对象。也就是说把要复制的对象所引用的对象都复制了一遍。

     还是以简历复制为例。

结构图


代码实现

简历类

<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;">//简历
    class Resume:ICloneable  
    {
        private string name;
        private string sex;
        private string age;

        private WorkExperience work;


        public Resume(string name)
        {
            this.name = name;
            work = new WorkExperience();
        }

        
        //提供Clone方法调用的私有构造函数,以便克隆“工作经历”的数据
        //与浅复制的不同之处
        private Resume(WorkExperience work)
        {
            this.work = (WorkExperience)work.Clone();
        }

        //设置个人信息
        public void SetPersonalInfo(string sex, string age)
        {
            this.sex = sex;
            this.age = age;
        }

        //设置工作经历
        public void SetWorkExperience(string workDate, string company)
        {
            work.WorkDate = workDate;
            work.Company = company;
            

        }

        //显示
        public void Display()
        {
            Console.WriteLine("{0}{1}{2}", name, sex, age);
            Console.WriteLine("工作经历:{0}{1}", work.WorkDate , work.Company);
        }

        //克隆
        public object Clone()

        {
            //调用私有的构造方法,让“工作经历”克隆完成,
            //然后再给简历对象的相关字段赋值,最终返回一个深复制的简历对象
            Resume obj = new Resume(this.work);
            obj.name = this.name;
            obj.sex = this.sex;
            obj.age = this.age;
            return obj;
            
        }
    }</span></span>

工作经历类

<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;"> 


 //工作经历
    //工作经历类实现接口
    class WorkExperience:ICloneable 
    {
        private string workDate;
        public string WorkDate
        {
            get { return workDate; }
            set { workDate = value; }
        }

        private string company;
        public string Company 
        {
            get { return company; }
            set { company = value; }
        }

        public Object Clone()
        {

            //工作经历类实现克隆方法 
            return (Object)this.MemberwiseClone();
        }

    }</span></span>

运行内存图如下:


      这样,最终结果实现了深复制,将WorkExperience实现接口ICloneable,因此work也可以执行Clone()方法,通过将类Resume的构造函数声明为private类型,并且类里面重写Clone()方法,实现了克隆简历的同时,也克隆了WorkExperience。

总结

一.需要具备以下两个条件

   实现Cloneable接口。在java语言有一个Cloneable接口,它的作用只有一个,就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在java虚拟机中,只有实现了这个接口的类才可以被拷贝,否则在运行时会抛出CloneNotSupportedException异常。

   重写Object类中的clone方法。Java中,所有类的父类都是Object类,Object类中有一个clone方法,作用是返回对象的一个拷贝,但是其作用域protected类型的,一般的类无法调用,因此,Prototype类需要将clone方法的作用域修改为public类型。

        原型模式是一种比较简单的模式,也非常容易理解,实现一个接口,重写一个方法即完成了原型模式。在实际应用中,原型模式很少单独出现。经常与其他模式混用,他的原型类Prototype也常用抽象类来替代。

二.原型模式的优点及适用场景

       使用原型模式创建对象比直接new一个对象在性能上要好的多,因为Object类的clone方法是一个本地方法,它直接操作内存中的二进制流,特别是复制大对象时,性能的差别非常明显。

       使用原型模式的另一个好处是简化对象的创建,使得创建对象就像我们在编辑文档时的复制粘贴一样简单。

       因为以上优点,所以在需要重复地创建相似对象时可以考虑使用原型模式。比如需要在一个循环体内创建对象,假如对象创建过程比较复杂或者循环次数很多的话,使用原型模式不但可以简化创建过程,而且可以使系统的整体性能提高很多。

三.原型模式的注意事项

    使用原型模式复制对象不会调用类的构造方法。因为对象的复制是通过调用Object类的clone方法来完成的,它直接在内存中复制数据,因此不会调用到类的构造方法。不但构造方法中的代码不会执行,甚至连访问权限都对原型模式无效。还记得单例模式吗?单例模式中,只要将构造方法的访问权限设置为private型,就可以实现单例。但是clone方法直接无视构造方法的权限,所以,单例模式与原型模式是冲突的,在使用时要特别注意。

    深拷贝与浅拷贝。Object类的clone方法只会拷贝对象中的基本的数据类型,对于数组、容器对象、引用对象等都不会拷贝,这就是浅拷贝。如果要实现深拷贝,必须将原型模式中的数组、容器对象、引用对象等另行拷贝。

 

评论 10
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值