原型模式

原型模式的定义：
 

用原型实例指定要创建的对象类型，通过复制这个实例创建新的对象
举一个例子（研磨设计模式中的例子）
例如现在有一个订单处理系统，接受订单对象，每个订单对象遵循相应的订单协议，即实现订单接口。
对于订单处理系统，只能接受订单数量小于1000的订单对象，如果订单对象的订单数量大于1000，则将该订单对象拆分成多个相同的订单对象
public interface OrderApi{
    //定义一些列订单操作，如订单数，订单放，日期等
}

public class PersonalOrder implements OrderApi{
    //私人订单
}
public class EnterpriseOrder implements OrderApi{
    //企业订单
}

public class OrderBusiness{
    public void saveOrder(OrderApi order){
    //业务需求，如果订单对象的订单数大于1000，要拆分成多个订单对象，每个订单对象的订单数不大于1000
    //1.判断订单对象的订单数是否大于1000
        while(order.orderNumber>1000){
            //如果订单数大于1000，拆分
            OrderApi newOrder = null;
            if(order instanceof PersonalOrder){
                PersonalOrder p2 = new PersonalOrder();
                personalOrder p1 = (PersonalOrder)order;
                p2.setParamaters(p1.getParameters);
                p2.setOrderNumber(1000);
                newOrder = p2;
            }
            if(order instanceof EnterpriseOrder){
                //与上面类似
            }
            //2.保存或处理新拆分元对象得到的新对象
            save(newOrder);
            order.setOrderNumber(order.orderNumber-1000);
        }
        //3.原订单对象的订单数已小于1000 可以直接处理保存。
        save(order);
    }
}
以上实现中，由于订单处理系统只接受订单接口，并不关心订单具体的实现，所以在拆分时，创建新的订单对象遇到麻烦，以上的
解决办法是通过instanceof判断订单类型。这样对于订单处理系统就必须知道所有的订单实现，也就是说订单处理系统和订单对象是
耦合在一起的，如果重新定义一个订单对象，势必重新改写订单处理系统的代码，即多加一个instanceof判断。

我们希望的实现是订单处理系统不关心订单对象有多少种实现，或者说我们的订单处理系统和订单是独立的，互不牵制。只要订单对象
实现订单接口，我们都能够对订单对象进行必要的处理如拆分和保存。如上代码，我们不用去判断订单对象到底属于何种类型。

原型模式可以解决此类问题。

在以上问题中，如果要拆分订单，得到新的订单对象，但并不知道订单对象的类型，如果使用原型模式，不必去判断订单类型，而是使用
复制，通过复制原型创建新的对象。通俗的讲，订单处理系统得到一个订单对象，发现他的订单数大于1000，需要拆分，复制原订单对象，
修改原订单对象和复制得到的对象的订单数。订单处理系统只知道原订单和复制对象都是接口类型。这样一来，不管新建多少个新的订单
对象，都不会影响订单系统的实现，实现了订单处理系统和订单对象的解耦合。
实现
public class PersonalOrder implements OrderApi{
    //私人订单
    //设置各种属性的方法
    //提供复制方法
    public OrderApi cloneOrder(){
        PersonalOrder order = new PersonalOrder();
        order.setParameters(this.parameters);
        return order;
    }
}

public class EnterpriseOrder implements OrderApi{
    //与PersonalOrder类似
}

public class OrderBusiness{
    public void saveOrder(OrderApi order){
        while(order.orderNumber > 1000){
            OrderApi newOrder = order.cloneOrder();
            newOrder.setOrderNumber(1000);
            order.setOrderNumber(order.orderNumber-1000);
            save(newOrder);
        }
        save(order);
    }
}

java中提供了clone()方法，只要类继承Cloneable接口，这个接口是一个标识接口，和序列化接口一样。复写其中的clone()方法即可
public Object clone(){
    Object obj = null;
    try{
        obj = super.clone();
    }catch(CloneNotSupportedException e){
        e.printStackTrace();
    }
    return obj;
}
不过复写的clone()方法返回Object类，在调用是还要在强制类型转换。
java中对于clone区分为深度克隆和浅度克隆
浅度克隆之是克隆按值传递的数据，如果某属性是引用类型，克隆无法完成引用类型的克隆，而只是复制引用，原对象和克隆对象
的引用共享同一个内存。（我的理解）
而深度克隆不仅克隆按值传递的数据，即使对于引用类型，要求该引用类型也必须实现cloneable接口，在深度克隆时，调用该
引用对象的clone方法克隆一个引用类型属性，如果该引用对象的属性仍然有引用类型，继续要求给引用类型实现Cloneable接口并
完成克隆，是一种递归克隆的过程，克隆出的对象和原对象的引用类型指向不同的内存，是两个不同的变量。


基于对象的克隆原型模式，实际上可以维护一个原型管理器，用于创建对象。
例如有一个原型接口：
public interface Prototype{//原型接口
    //原型方法：如setName setID getName
    public Prototype clone();
}

public class ConcretePrototype1 implements Prototype{//原型类
    //属性和方法定义
    public Prototype clone(){
        ConcretePrototype1 prototype = new Concretetype1();
        prototype.setName();
        return prototype;
    }
}
public class ConcretePrototype2 implements Prototype{
    //属性和方法定义
    public Prototype clone(){
        ConcretePrototype2 prototype = new Concretetype1();
        prototype.setName();
        return prototype;
    }
}
public class ConcretePrototype4 implements Prototype{
    //属性和方法定义
    public Prototype clone(){
        ConcretePrototype3 prototype = new Concretetype1();
        prototype.setName();
        return prototype;
    }
}
...
public class PrototypeManager{
    private static Map map = new HashMap();
    private PrototypeManager(){};//私有构造方法
    public synchronized static void regeistPrototye(String prototypeID,Prototype prototype){
        map.put(prototypeID,prototype);
    }
    public synchronized static void removePrototype(String prototypeID){
        map.remove(prototypeID);
    }
    public synchronized static Prototype getPrototype(String prototypeID) throws Exception{
        Prototype p = map.get(prototypeID);
        if(p == null){
            throw new Exception("此原型未注册")
        }
        return p;
    }
}

从原型管理器可以看出，原型模式应该是属于一种创建型的设计模式。