关于Clone

一般情况下，如果使用clone()方法，则需满足以下条件。
1、对任何对象o，都有o.clone() != o。换言之，克隆对象与原型对象不是同一个对象。
2、对任何对象o，都有o.clone().getClass() == o.getClass()。换言之，克隆对象与原型对象的类型一样。
3、如果对象o的equals()方法定义恰当，则o.clone().equals(o)应当成立。

我们在设计自定义类的clone()方法时，应当遵守这3个条件。一般来说，这3个条件中的前2个是必需的，第3个是可选的。

浅拷贝

super.clone()方法直接从堆内存中以二进制流的方式进行复制，重新分配一个内存块，因此其效率很高。
由于super.clone()方法基于内存复制，因此不会调用对象的构造函数，也就是不需要经历初始化过程。
只有基本类型的参数会被拷贝一份，非基本类型的对象不会被拷贝一份，而是继续使用传递引用的方式，原型对象与克隆对象的该属性只是指向同一对象的引用，即浅拷贝。

	@Overridepublic Object clone() throws CloneNotSupportedException{Employees employees = (Employees)super.clone();return employees;}

深拷贝

在日常开发中，使用super.clone()方法并不能满足所有需求。如类中存在引用对象属性。就要需要实现深拷贝，必须要自己手动修改 clone 方法才行。

	@Overridepublic Object clone() throws CloneNotSupportedException{List<String> temp = new ArrayList<String>();for(String s : this.getEmpList()){temp.add(s);}return new Employees(temp);}

使用序列化（Serializable）

不过如果当原型对象维护很多引用属性的时候，手动分配会比较烦琐。因此，在Java中，如果想完成原型对象的深克隆，则通常使用 序列化（Serializable）的方式。

public class Employees implements Cloneable,Serializable{private List<String> empList;public Employees(){empList = new ArrayList<String>();}public Employees(List<String> list){this.empList=list;}public void loadData(){//read all employees from database and put into the listempList.add("Pankaj");empList.add("Raj");empList.add("David");empList.add("Lisa");}public List<String> getEmpList() {return empList;}@Overridepublic Object clone() throws CloneNotSupportedException{List<String> temp = new ArrayList<String>();for(String s : this.getEmpList()){temp.add(s);}return new Employees(temp);}public Object deepClone() throws CloneNotSupportedException{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 (Employees)ois.readObject();} catch (IOException | ClassNotFoundException e) {e.printStackTrace();return null;}}
}

测试

	public static void main(String[] args) throws CloneNotSupportedException {Employees emps = new Employees();emps.loadData();Employees empsNew = (Employees) emps.deepClone();Employees empsNew1 = (Employees) emps.deepClone();List<String> list = empsNew.getEmpList();list.add("John");List<String> list1 = empsNew1.getEmpList();list1.remove("Pankaj");System.out.println("emps List: "+emps.getEmpList());System.out.println("empsNew List: "+list);System.out.println("empsNew1 List: "+list1);}emps List: [Pankaj, Raj, David, Lisa]
empsNew List: [Pankaj, Raj, David, Lisa, John]
empsNew1 List: [Raj, David, Lisa]

---

还原克隆破坏单例的事故现场
假设有这样一个场景，如果复制的目标对象恰好是单例对象，那会不会使单例对象被破坏呢？
当然，我们在已知的情况下肯定不会这么干，但如果发生了意外怎么办？不妨来试一下

public class A11_EagerInitializedSingletonClone implements Cloneable {private static final A11_EagerInitializedSingletonClone instance = new A11_EagerInitializedSingletonClone();// private constructor to avoid client applications to use constructorprivate A11_EagerInitializedSingletonClone() {}public static A11_EagerInitializedSingletonClone getInstance() {return instance;}@Overridepublic A11_EagerInitializedSingletonClone clone() throws CloneNotSupportedException{A11_EagerInitializedSingletonClone employees = (A11_EagerInitializedSingletonClone)super.clone();return employees;}
}

A11_EagerInitializedSingletonClone instanceOne = A11_EagerInitializedSingletonClone.getInstance();
A11_EagerInitializedSingletonClone instanceOne2  = instanceOne.clone();
System.out.println(instanceOne==instanceOne2);

结果为false确实创建了两个不同的对象。

实际上防止复制破坏单例对象的解决思路非常简单，禁止复制便可。要么我们的单例类不实现Cloneable接口，要么我们重写clone()方法，在clone()方法中返回单例对象即可，具体代码如下

	@Overridepublic A11_EagerInitializedSingletonClone clone() throws CloneNotSupportedException{return instance;}

A11_EagerInitializedSingletonClone instanceOne = A11_EagerInitializedSingletonClone.getInstance();
A11_EagerInitializedSingletonClone instanceOne2  = instanceOne.clone();
System.out.println(instanceOne==instanceOne2);

结果为true