设计模式之原型模式(四)

设计模式之原型模式(四)

　　刚刚写了建造者模式,接下来我们来学习原型模式......

　　一  概念

　　原型模式是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

　　这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

　　二 介绍

　　意图：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

　　主要解决：在运行期建立和删除原型。

　　何时使用： 1、当一个系统应该独立于它的产品创建，构成和表示时。 2、当要实例化的类是在运行时刻指定时，例如，通过动态装载。 3、为了避免创建一个与产品类层次平行的工厂类层次时。 4、当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。

　　如何解决：利用已有的一个原型对象，快速地生成和原型对象一样的实例。

　　关键代码： 1、实现克隆操作，在 JAVA 继承 Cloneable，重写 clone()，在 .NET 中可以使用 Object 类的 MemberwiseClone() 方法来实现对象的浅拷贝或通过序列化的方式来实现深拷贝。 2、原型模式同样用于隔离类对象的使用者和具体类型（易变类）之间的耦合关系，它同样要求这些"易变类"拥有稳定的接口。

　　应用实例： 1、细胞分裂。 2、JAVA 中的 Object clone() 方法。

　　优点： 1、性能提高。 2、逃避构造函数的约束。

　　缺点： 1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。 2、必须实现 Cloneable 接口。

　　使用场景： 1、资源优化场景。 2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。 3、性能和安全要求的场景。 4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。 5、一个对象多个修改者的场景。 6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。 7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。

　　注意事项：与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。

　　三  图解原型模式

 

　　四  举例说明

接下来我来举两个经典的例子:1  细胞分裂 ,2  孙悟空变身, 这两了例子都是可以通过原型来克隆自己,比如孙悟空可以通过原型来变成两个孙悟空,三个孙悟空......

要实现原型模式,prototype要实现一个ICloneable接口来重写clone()方法,接下来看我的代码展示

 

/// <summary>
    /// 主程序
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            Car car = new Car(123, "奔驰", 8888);
            SunwkPrototype sunPrototype = new ConcretePrototypeOne("变身", 18, car);
            SunwkPrototype sunPrototypeTwo = sunPrototype.Clone() as SunwkPrototype;
            Console.WriteLine(sunPrototype.ToString());
            Console.WriteLine(sunPrototypeTwo.ToString());
            Console.ReadKey();

            //这时是浅复制,我们把sunPrototype的car引用对象的价格改变,sunPrototypeTwo的car属性也会跟着改变
            Console.WriteLine("===================浅复制,复制的是引用,指向的是同一个引用对象,我们来看一下====================");
            sunPrototype.Name = "看我变身";//string类型
            sunPrototype.Age = 19;//值类型
            sunPrototype.Car.Price = 9999;//引用类型
            Console.WriteLine(sunPrototype.ToString());
            Console.WriteLine(sunPrototypeTwo.ToString());
            Console.ReadKey();

            //Car car = new Car(123, "奔驰", 8888);
            //SunwkPrototype sunPrototype = new ConcretePrototypeOne("变身", 18, car);
            //SunwkPrototype sunPrototypeTwo = sunPrototype.DeepClone();
            //Console.WriteLine(sunPrototype.ToString());
            //Console.WriteLine(sunPrototypeTwo.ToString());
            //Console.ReadKey();
            ////下面是深复制
            //sunPrototype.Name = "看我变身";//string类型
            //sunPrototype.Age = 19;//值类型
            //sunPrototype.Car.Price = 9999;//引用类型
            //Console.WriteLine(sunPrototype.ToString());
            //Console.WriteLine(sunPrototypeTwo.ToString());
            //Console.ReadKey();
        }
    }
===================================
/// <summary>
    /// 孙悟空原型抽象
    /// </summary>
    public abstract class SunwkPrototype:ICloneable
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public Car Car { get; set; }
        public SunwkPrototype(string name,int age,Car car) {
            this.Name = name;
            this.Age = age;
            this.Car = car;
        }
        //浅复制
        public abstract object Clone();
        //深复制
        public abstract  SunwkPrototype DeepClone();

        public override string ToString()
        {
            return this.Name + "   " + this.Age + "   " + this.Car.ToString();
        }
    }
===================================
/// <summary>
    /// 孙悟空原型实现
    /// </summary>
    public class ConcretePrototypeOne : SunwkPrototype
    {
        public ConcretePrototypeOne(string name,int age,Car car):base( name, age, car)
        {
            
        }
        //浅复制
        public override object Clone()
        {
            return this.MemberwiseClone();
        }
        //深复制
        public override  SunwkPrototype DeepClone()
        {
            SunwkPrototype sun = this.MemberwiseClone() as SunwkPrototype;
            sun.Car = new Car(Car.Id, Car.Name, Car.Price);
            return sun;
        }
    }
===================================
 public class Car
    {
        public Car(int id, string name, int price)
        {
            this.Id = id;
            this.Name = name;
            this.Price = price;
        }
        public int Id { get; set; }
        public string Name { get; set; }
        public int Price { get; set; }

        public override string ToString()
        {
            return this.Id + "   " + this.Name + "   " + this.Price;
        }

    }

 

接下来我们看一下运行结果

 

为了展示浅复制和深复制的区别,我加入了Car类表示引用类型

从运行结果中我们可以看出来,当我们把原型对象改变之后,即string类型(string name 变成了看我变身)和值类型(int age 变成了19)之后

克隆的对象 "变身"和18,这两个属性没有改变,说明实现的是深复制

而引用类型(Car)则是实现的浅复制,引用的是同一个对象,所以当改变原型对象的Car 的price属性,由8888改变为9999之后,克隆对象的Car属性也跟着变化了

下面我画一张图帮助理解一下

 

所以说:浅复制,复制的是引用对象的引用地址,指向的是同一块内存空间,而深复制则是将在内存中开辟了一块空间来存储引用对象,指向的是不用的地址

所以:浅复制,共享同一个对象,原型对象更改时,克隆对象也跟着更改,反之,同理;而深复制原型对象更改时,克隆对象不会更改

 下面我们来更改主程序,实现深复制,来印证上面的说法

class Program
    {
        static void Main(string[] args)
        {
            //Car car = new Car(123, "奔驰", 8888);
            //SunwkPrototype sunPrototype = new ConcretePrototypeOne("变身", 18, car);
            //SunwkPrototype sunPrototypeTwo = sunPrototype.Clone() as SunwkPrototype;
            //Console.WriteLine(sunPrototype.ToString());
            //Console.WriteLine(sunPrototypeTwo.ToString());
            //Console.ReadKey();

            ////这时是浅复制,我们把sunPrototype的car引用对象的价格改变,sunPrototypeTwo的car属性也会跟着改变
            //Console.WriteLine("===================浅复制,复制的是引用,指向的是同一个引用对象,我们来看一下====================");
            //sunPrototype.Name = "看我变身";//string类型
            //sunPrototype.Age = 19;//值类型
            //sunPrototype.Car.Price = 9999;//引用类型
            //Console.WriteLine(sunPrototype.ToString());
            //Console.WriteLine(sunPrototypeTwo.ToString());
            //Console.ReadKey();

            Car car = new Car(123, "奔驰", 8888);
            SunwkPrototype sunPrototype = new ConcretePrototypeOne("变身", 18, car);
            SunwkPrototype sunPrototypeTwo = sunPrototype.DeepClone();
            Console.WriteLine(sunPrototype.ToString());
            Console.WriteLine(sunPrototypeTwo.ToString());
            Console.ReadKey();
            //下面是深复制
            sunPrototype.Name = "看我变身";//string类型
            sunPrototype.Age = 19;//值类型
            sunPrototype.Car.Price = 9999;//引用类型
            Console.WriteLine(sunPrototype.ToString());
            Console.WriteLine(sunPrototypeTwo.ToString());
            Console.ReadKey();
        }
    }

将上面浅复制注释掉,打开深复制,DeepCopy();

下面展示一下结果

可以看到当原型对象 的引用对象Car 的属性price 由8888变为9999时

克隆对象依然是8888,所以实现的是深复制

注:我了解到的实现深复制的三种方式:1 序列化和反序列话 2 转json 3 手动复制

好了,原型模式就写到这吧

欢迎各位指正,纠错,共同进步