6、原型模式

原型模式：

用原型实例指定创建对象的种类，并且通过拷贝这种原型创建新的对象。（从一个对象再创建另外一个可定制的对象，而且不需要知道任何创建的细节）

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

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

原型模式UML结构图：

对于深复制与浅复制（深拷贝与浅拷贝）的简单区别：

浅拷贝：只负责克隆按值传递的数据（比如基本数据类型、String类型），所有引用的对象仍然指向原来的对象，即修改该引用对象时修改的是最初的那个对象。
深拷贝：除了浅拷贝要克隆的值外，还负责克隆引用类型（属性的类型也是对象）的数据，即把引用对象的变量指向复制过的新对象，而不是，而不是原有被引用的对象，即修改该引用对象时不会影响最初的那个对象。

我们在执行Clone函数本身时，实际其内部实现是浅复制，当我们需要的属性值是引用对象并需要作出修改时，我们就应该采用深复制的手段（重写Clone函数，使得每一步都是浅复制）

例（原型模式基本代码）：

	abstract class Prototype
    {
        private string id;

        // Constructor 
        public Prototype(string id)
        {
            this.id = id;
        }

        // Property 
        public string Id
        {
            get { return id; }
        }

        public abstract Prototype Clone();  //关键在于此接口
    }

    class ConcretePrototype1 : Prototype
    {
        // Constructor 
        public ConcretePrototype1(string id)
            : base(id)
        {
        }

        public override Prototype Clone()
        {
            // Shallow copy 
            return (Prototype)this.MemberwiseClone();  //创建当前对象的浅复制副本，方法是创建一个新对象，然后将当前对象的非静态字段复制到该新对象，如果字段是值类型的，则对该字段执行逐位复制，如果该字段是引用类型，则复制其引用但是不复制引用的对象。
        }
    }


    class ConcretePrototype2 : Prototype
    {
        // Constructor 
        public ConcretePrototype2(string id)
            : base(id)
        {
        }

        public override Prototype Clone()
        {
            // Shallow copy 
            return (Prototype)this.MemberwiseClone();
        }
    }

	//Client:
	ConcretePrototype1 p1 = new ConcretePrototype1("I");
    ConcretePrototype1 c1 = (ConcretePrototype1)p1.Clone();

由于克隆实在太过常用，在.NET中System命名空间提供了ICloneable接口，其中唯一的方法就是Clone（），我们只需要实现这个接口就好了，就不用再新定义Prototype原型象类了。

例（简历复制——C#）：

	//简历
    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();
        }
    }

上面的案例都是浅复制实现，如果我们涉及到引用对象时，就要采用深复制（有的时候引用里面嵌套这引用，导致引用有很多层，操作就会比较复杂，深复制需要深入到多少层需要事先就要考虑好，同时必须注意避免循环引用的问题，否则程序将会一直执行复制操作，陷入死循环）。

例（简历复制（深复制）——C#）：

 	//简历
    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();
        }

        private Resume(WorkExperience work)  //提供给Clone函数调用的私有构造函数，以便克隆“工作经历”数据。
        {
            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;
        }

    }

    //工作经历
    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();
        }
    }

在某些特定场合，会经常用到深复制和浅复制，比如在数据集对象DataSet，就有Clone（）方法和Copy（）方法，Clone（）方法用来复制DataSet的结构但是不复制数据，实现了原型模式的浅复制，Copy（）方法不但复制结构也复制数据，其实就是实现了原型模式的深复制。

Prototype模式与Factory模式的关系 ：

虽然原型引入的初衷是像上面所说，但实现起来，却完全可以达到工厂模式的效果；而且，用起来甚至比工厂模式更方便、灵活。对于工厂模式与原形模式在功能上 的这点巧合，也许是因为本来工厂模式和 原型模式都是创建型模式，这样，他们的基本功能都能生成对象，因而使得原型模式在功能上可以代替工厂模式。

在原型模式中，你完全可以同样定义一个这样的 “抽象产品——具体产品”层次，再利用具体产品本身的clone功能来产生具体产品本身。从而达到实现工厂模 式功能的目的。实际上，在原型模式中，每个具体产品就扮演了工厂模 式里的具体工厂的角色（因为每个具体产品都具有生成自己拷贝的功能，从这种意义上讲，这正是工厂的作用）。
原型模式提供了简化的创建结构。工厂方法模式常常需要有一个与产品类等级结构相同的等级结构，而原型模式就不需要这样。

Prototype模式的最主要缺点就是每个原 型的子类都必须实现clone的操作，尤其在包含引用类型的对象时，clone方法会比较麻烦，必须要能够递归地让所有的相关对象都要正确地实现克隆。

下面我们对上面的内容强化练习一下（这次我们采用Java版本）：

例（订单处理系统（深复制）——Java）：

现在有一个订单处理系统，里面有一个保存订单的业务 功能，需求：每当订单的预定产品数量超过1000的时候，就需要把订单拆成两份订单来保存。如果拆成两份后还是超过1000，则继续拆分，直到每份产品预订数量不超过1000。
根据业务，目前的订单系统分成两种，一种是个人订单、一种是公司订单。
客户名称、产品对象（ID，Name），订购产品数量。
公司名称、产品对象（ID，Name），订购产品数量。

UML图：

//Product(产品类):

/*
 * 浅克隆（浅复制）是对要克隆的对象，其中的基本类型复制一份新的产生给对象。但是对于非基本类型的数据类型，仅仅是复制一份引用给新产生的对象。
 * 即基本类型是新产生的，非基本类型是复制一份内存引用。
 * 
 * 实现步骤：
 * 1.实现Cloneable接口
 * 要clone方法，为什么还要实现Cloneable接口呢？我们可以看看，Cloneable其中是一个空方法，它和RandomAccess一样都属于，标识接口。
 * 针对的是Object里的clone方法，进行重写。告诉Object而已。
 * 如果调用了super.clone()方法。没有实现Cloneable接口。那么会抛出异常CloneNotSupportedException异常。
 * 
 * 2.重写clone方法。
 * JDK中的API文档也说明了，这是一个对象拷贝的过程，不是对象的初始化过程。他包含了一些原有对象的信息。
 * Object中的clone的返回值是native。
 * native属于一般是由C语言实现，效率一般都高于java代码，所以这里我们没有选择new一个新的对象，而是选择对象拷贝。
 * 
 * Object中的clone修饰符是protected，我们要把它改成public。
 */

/*
 * 深度克隆，其实就是对于浅度克隆的一种完善，浅度克隆只能完成基本类型的克隆，对于非基本类型无法克隆，只能复制内存地址到新的对象上。
 * 而深度克隆不同，深度克隆是完成了，基本数据类型和非基本数据类型，都可以克隆。
 * 深复制重点在于：在主类上添加子类的Clone方法。（即多层浅复制）
 */

public class Product implements Cloneable {

	private int ID;
	private String name;
	public Product() {
		super();
	}
	public Product(int iD, String name) {
		super();
		ID = iD;
		this.name = name;
	}
	public int getID() {
		return ID;
	}
	public void setID(int iD) {
		ID = iD;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	@Override
	public Object clone() throws CloneNotSupportedException {
		//数据类型都是基本数据类型，执行浅复制
		return super.clone();	
	}
	
	@Override
	public String toString() {
		return "  ID："+ID+" Name："+name;
	}
}

//Order（订购顺序）：

public class Order implements Cloneable {

	private int num;
	private String name;
	private Product product;
	public Order() {
		super();
	}
	public Order(int num, String name, Product product) {
		super();
		this.num = num;
		this.name = name;
		this.product = product;
	}
	public int getNum() {
		return num;
	}
	public void setNum(int num) {
		this.num = num;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Product getProduct() {
		return product;
	}
	public void setProduct(Product product) {
		this.product = product;
	}
	@Override
	public Object clone() throws CloneNotSupportedException {
		//首层浅复制
		Order order = (Order) super.clone();
		//相对于order的深复制（相对于product的浅复制）
		//深复制实质是多层浅复制
		order.setProduct((Product)product.clone());
		return order;
	}
	@Override
	public String toString() {
		return "订单数目："+num+"  订单类型："+name+product.toString();
	}
}

//main:

import java.util.ArrayList;
import java.util.List;

public class Test {
	 
    public static void main(String[] args) throws CloneNotSupportedException {
        int MAX=1000;
    	List<Order> list = new ArrayList<Order>();
        Product product = new Product(1, "产品1");
        Order order = new Order(3000,"公司订单",product);
        int y=order.getNum();
        while (y>MAX) {
            Order tmp = (Order) order.clone();
            tmp.setNum(MAX);
            list.add(tmp);
            y=order.getNum()-MAX;
            order.setNum(y);       
        }
        list.add(order);
        System.out.println("共有"+list.size()+"份订单");
        for (int i=0; i<list.size(); i++) {
            System.out.println(list.get(i).toString());
        } 
    }
}