原型模式，思维导图+代码，原来这么简单！

原型模式 prototype pattern，是一种创建型模式，即创建对象的模式，通过实现 Cloneable接口，来进行对象的创建，简单来说就是对象的拷贝。

对象的拷贝又分为浅拷贝和深拷贝两种。浅拷贝属于赋值值类型数据，深拷贝把引用对象也拷贝了。

下面看代码，这段代码的大概意思是：有一个小动物叫发财，它太可爱了，很多人都喜欢它，都想拥有它，所以对它进行了克隆，它有一个Id、名字和性别，并且它的毛色是黑色+白色的，通过代码看看浅克隆和深克隆的区别吧。

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.List;

/**
 * 实现克隆、序列化接口
 * 深克隆，必须实现Serializable接口
 * @author 程就人生
 * @Date
 */
public class Animal implements Cloneable,Serializable{
  
  private static final long serialVersionUID = 1L;

  private String id;
  
  private String name;
  
  private Byte sex;
  
  private List<String> colorList;

  public String getId() {
    return id;
  }

  public void setId(String id) {
    this.id = id;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public Byte getSex() {
    return sex;
  }

  public void setSex(Byte sex) {
    this.sex = sex;
  }
  
  public List<String> getColorList() {
    return colorList;
  }

  public void setColorList(List<String> colorList) {
    this.colorList = colorList;
  }
  
  /**
   * 浅克隆
   */
  public Object shallowClone() {
        Object clone = null;
        try {
           clone = super.clone();
        } catch (CloneNotSupportedException e) {
           e.printStackTrace();
        }
        return clone;
  }
  
  /**
   * 深克隆
   */
  public Object deepClone(){
    try{
      ByteArrayOutputStream bos = new ByteArrayOutputStream();
      ObjectOutputStream oos = new ObjectOutputStream(bos);
      oos.writeObject(this);
      
      ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
      ObjectInputStream ois = new ObjectInputStream(bis);      
      return ois.readObject();
    }catch(Exception e){
      e.printStackTrace();
    }
    return null;
  }  
}

测试代码：

Animal p = new Animal();
p.setId("123456");
p.setName("发财");
p.setSex((byte) 0);
List<String> colorList = new ArrayList<String>();
colorList.add("黑色");
colorList.add("白色");
p.setColorList(colorList);
Animal cloneP = (Animal) p.shallowClone();
cloneP.setId(cloneP.getId()+"1");
  
System.out.println("浅克隆：");
System.out.println(p == cloneP);
System.out.println(p.getColorList() == cloneP.getColorList());

cloneP = (Animal) p.deepClone();  
cloneP.setId(cloneP.getId()+"1");
System.out.println("深克隆：");
System.out.println(p == cloneP);
System.out.println(p.getColorList() == cloneP.getColorList());

测试结果：

浅克隆：
false
true
深克隆：
false
false

怎么样，是不是很简单！

思考题：一个对象需要在一个高代价的数据库操作之后被创建。那么是使用 单例模式 还是 原型模式？

也许有人会问，它会不会破坏单例呢，答案是：当然会的。

如果是单例模式，那么就在clone方法上禁止克隆吧！

throws CloneNotSupportedExcedption