java中的原型模式

有的时候，我们需要一个实例时，并且，当创建一个实例的过程比较复杂或者说是昂贵时，

比如，创建实例的构造函数非常的复杂，在执行这个构造函数时会消耗较长的时间，

同时呢，这个构造函数中的一些信息又没有什么变化

（也就是说创建第一个实例时初始化信息是这样的，创建第二个实例时初始化信息还是还是这样的），

那么直接使用 new 来创建这样一个实例就显得太昂贵了，

最好的解决方法，并不是使用 new 来实例化一个对象，

而是使用克隆，也就是复制，克隆呢，就是通过复制现在已经有了的实例来创建新的实例，

这样有什么好处呢？

很明显，这样实现呢，客户端根本就不知道具体要实例化的是哪一个类，

它只知道是复制了，但具体的实例化情况，它却是一无所知的，这样便对客户端进行了隐藏，

同时，复制一个对象一般情况下会比创建一个对象性能更高（当然有时候也不一定，只是一般情况而已），

其实上面所提到的就是下面要介绍的一个设计模式--原型模式（Prototype），

         

        

原型模式（Prototype） 

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

换句话说，原型模式就是通过复制现在已经存在的对象来创建一个新的对象。

        

原型模式的结构类图如下：

从上面这副类图中，可以看出，在 AbstractPrototype 中只声明了一个方法，那就是克隆自身。

            

下面我们就来看一看原型模式的具体实现：

下面就直接把上面三个类的代码贴出来：

namespace Prototype
{
    public abstract class AbstractPrototype
    {
        private string name;

        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        /// <summary>
        /// 在抽象类中声明一个克隆方法
        /// </summary>
        /// <returns></returns>
        public abstract AbstractPrototype Clone();
    }
}

          

namespace Prototype
{
    public class ConcretePrototypeA : AbstractPrototype
    {
        public ConcretePrototypeA(string name)
        {
            this.Name = name;
        }

        public override AbstractPrototype Clone()
        {
           /* 摘自 MSDN:
              MemberwiseClone 方法创建一个浅表副本
              方法是创建一个新对象
              然后将当前对象的非静态字段复制到该新对象
              如果字段是值类型的
              则对该字段执行逐位复制
              如果字段是引用类型
              则复制引用但不复制引用的对象
              因此，原始对象及其复本引用同一对象。
              例如，考虑一个名为 X 的对象，
              该对象引用对象 A 和 B,对象 B 又引用对象 C
              X 的浅表副本创建一个新对象 X2,该对象也引用对象 A 和 B
              与此相对照,X 的深层副本创建一个新对象 X2,
              该对象引用新对象 A2 和 B2，它们分别是 A 和 B 的副本
              B2 又引用新对象 C2，C2 是 C 的副本
              使用实现 ICloneable 接口的类执行对象的浅表或深层复制
            */
            return (AbstractPrototype)this.MemberwiseClone();
        }
    }
}

       

namespace Prototype
{
    public class ConcretePrototypeB : AbstractPrototype
    {
        public ConcretePrototypeB(string name)
        {
            this.Name = name;
        }

        public override AbstractPrototype Clone()
        {
            return (AbstractPrototype)this.MemberwiseClone();
        }
    }
}

下面就看看客户端代码得使用了

using System;
using Prototype;

namespace PrototypeTest
{
    class Program
    {
        static void Main(string[] args)
        {
           //首先是要实例化一个原型对象
            AbstractPrototype prototypeA = new ConcretePrototypeA("A");
            //根据这个原型对象来克隆一个新的对象
            AbstractPrototype prototypeB = prototypeA.Clone();
            Console.WriteLine(prototypeA.Name);
            Console.WriteLine(prototypeB.Name);

             

            //再修改复制所得的对象
            prototypeB.Name = "B";

               

            Console.WriteLine("/n" + prototypeA.Name);
            Console.WriteLine(prototypeB.Name);
            Console.Read();
        }
    }
}

效果展示：

上面呢，便对原型模式进行了最简单的实现