原型模式

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

    public class PrototypeClass implements Cloneable{

         //覆写父类Object方法
         @Override
         public PrototypeClass clone(){
                 PrototypeClass prototypeClass = null;
                 try {
                        prototypeClass = (PrototypeClass)super.clone();
                 } catch (CloneNotSupportedException e) {
                        //异常处理
                 }
                 return prototypeClass;
         }
    }

原型模式已经与Java融为一体，大家可以随手拿来使用。

资源性能优化场景:

类初始化需要非常繁琐的数据准备，需要消化非常多的资源，这个资源包括数据、硬件资源等。

一个对象多个修改者的场景:

一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。

注意:

clone时构造函数不会被执行，Object类的clone方法的原理是从内存中（具体地说就是堆内存）以二进制流的方式进行拷贝，重新分配一个内存块，那构造函数没有被执行也是非常正常的了。

浅拷贝和深拷贝:

关于浅拷贝：

    public class Thing implements Cloneable{
         //定义一个私有变量
         private ArrayList arrayList = new ArrayList();

         @Override
         public Thing clone(){
                 Thing thing=null;
                 try {
                        thing = (Thing)super.clone();
                 } catch (CloneNotSupportedException e) {
                        e.printStackTrace();
                 }
                 return thing;
         }
         public void setValue(String value){
                 this.arrayList.add(value);
         }
         public ArrayList getValue(){
                 return this.arrayList;
         }
    }

Object类提供的方法clone只是拷贝本对象，其对象内部的数组、引用对象等都不拷贝，还是指向原生对象的内部元素地址，这种拷贝就叫做浅拷贝。

原始类型+装箱类型+String 会被拷贝，但其他的内部成员对象和数组不会拷贝，只会拷贝其引用。

关于深拷贝：

    public class Thing implements Cloneable{
         //定义一个私有变量
         private ArrayList arrayList = new ArrayList();
         @Override
         public Thing clone(){
                 Thing thing=null;
                 try {
                        thing = (Thing)super.clone();
                        thing.arrayList = (ArrayList)this.arrayList.clone();
                 } catch (CloneNotSupportedException e) {
                        e.printStackTrace();
                 }
                 return thing;
         }
    }

注意这里数组与ArrayList等clone，只会拷贝内部元素的引用数组，并不会深拷贝数组内部的元素。

关于一些其他的拷贝的姿势：

1.序列化（List深拷贝）

    public static List deepCopy(List src) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(byteOut);
        out.writeObject(src);

        ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
        ObjectInputStream in = new ObjectInputStream(byteIn);
        List dest = (List) in.readObject();
        return dest;
    }

2.System.arraycopy（数组的浅拷贝）

这个方法不是用java语言写的，而是底层用c或者c++实现的，因而速度会比较快。但是是浅拷贝

3.Arrays.copyOf（数组的浅拷贝）

调用的是System.arraycopy，如ArrayList的clone方法调用的就是Arrays.copyOf。

备忘录模式

定义：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。

角色：

发起人角色：记录当前时刻的内部状态，负责定义哪些属于备份范围的状态，负责创建和恢复备忘录数据。

备忘录角色：负责存储发起人对象的内部状态，在需要的时候提供发起人需要的内部状态。

Caretaker备忘录管理员角色：对备忘录进行管理、保存和提供备忘录。

    //发起人角色
    public class Originator {
         //内部状态
         private String state = "";

         public String getState() {
                 return state;
         }
         public void setState(String state) {
                 this.state = state;
         }
         //创建一个备忘录
         public Memento createMemento(){
                 return new Memento(this.state);
         }
         //恢复一个备忘录
         public void restoreMemento(Memento _memento){
                 this.setState(_memento.getState());
         }
    }

    //备忘录角色
    public class Memento {
         //发起人的内部状态
         private String state = "";
         //构造函数传递参数
         public Memento(String _state){
                 this.state = _state;
         }
         public String getState() {
                 return state;
         }
         public void setState(String state) {
                 this.state = state;
         }
    }

    //备忘录管理员角色
    public class Caretaker {
         //备忘录对象
         private Memento memento;
         public Memento getMemento() {
                 return memento;
         }
         public void setMemento(Memento memento) {
                 this.memento = memento;
         }
    }

    public class Client {
         public static void main(String[] args) {
                 //定义出发起人
                 Originator originator = new Originator();
                 //定义出备忘录管理员
                 Caretaker caretaker = new Caretaker();
                 //创建一个备忘录
                 caretaker.setMemento(originator.createMemento());
                 //恢复一个备忘录
                 originator.restoreMemento(caretaker.getMemento());
         }
    }

备忘录模式变种：

1.clone 方式的备忘录（发起者与备忘录融合）

    //发起者与备忘录融合
    public class Originator implements Cloneable{
         //内部状态
         private String state = "";

         public String getState() {
                 return state;
         }
         public void setState(String state) {
                 this.state = state;
         }
         //创建一个备忘录
         public Originator createMemento(){
                 return this.clone();
         }
         //恢复一个备忘录
         public void restoreMemento(Originator _originator){
                 this.setState(_originator.getState());
         }
         //克隆当前对象
         @Override
         protected Originator clone(){
                 try {
                         return (Originator)super.clone();
                 } catch (CloneNotSupportedException e) {
                         e.printStackTrace();
                 }
                 return null;
         }
    }

    public class Caretaker {
         //发起人对象
         private Originator originator;
         public Originator getOriginator() {
                 return originator;
         }
         public void setOriginator(Originator originator) {
                 this.originator = originator;
         }
    }

1.clone 方式的备忘录（发起者与备忘录和管理者 融合）

    public class Originator implements Cloneable{
         private Originator backup;
         //内部状态
         private String state = "";
         public String getState() {
                 return state;
         }
         public void setState(String state) {
                 this.state = state;
         }
         //创建一个备忘录
         public void createMemento(){
                 this.backup = this.clone();
         }
         //恢复一个备忘录
         public void restoreMemento(){
                 //在进行恢复前应该进行断言，防止空指针
                 this.setState(this.backup.getState());
         }
         //克隆当前对象
         @Override
         protected Originator clone(){
                 try {
                         return (Originator)super.clone();
                 } catch (CloneNotSupportedException e) {
                         e.printStackTrace();
                 }
                 return null;
         }
    }

提问？在该对象之外保存这个状态，是否矛盾？

现在我们来考虑一下原型模式深拷贝和浅拷贝的问题，在复杂的场景下它会让你的程序逻辑异常混乱，出现错误也很难跟踪。因此Clone方式的备忘录模式适用于较简单的场景。

多状态的时候需要怎么写？

    public class Caretaker {
         //容纳备忘录的容器
         private ArrayMap<String,Memento> memMap = new ArrayMap<String,Memento>();
         public Memento getMemento(String idx) {
                 return memMap.get(idx);
         }
         public void setMemento(String idx,Memento memento) {
                 this.memMap.put(idx, memento);
         }
    }