大家都知道在Java中所有的类都是缺省的继承自Java语言包中的Object类的，查看它的源码，你可以把你的JDK目录下的src.zip复制到其他地方然后解压，里面就是所有的源码。发现里面有一个访问限定符为protected的方法clone()：
protected native Object clone() throws CloneNotSupportedException;
仔细一看，它还是一个native方法，大家都知道native方法是非Java语言实现的代码，供Java程序调用的，因为Java程序是运行在JVM虚拟机上面的，要想访问到比较底层的与操作系统相关的就没办法了，只能由靠近操作系统的语言来实现。
为什么要克隆？
大家先思考一个问题，为什么需要克隆对象？直接new一个对象不行吗？答案是：克隆的对象可能包含一些已经修改过的属性，而new出来的对象的属性都还是初始化时候的值，所以当需要一个新的对象来保存当前对象的“状态”就靠clone方法了。那么我把这个对象的临时属性一个一个的赋值给我新new的对象不也行嘛？可以是可以，但是一来麻烦不说，二来，大家通过上面的源码都发现了clone是一个native方法，就是快啊，在底层实现的。提个醒，我们常见的Object a=new Object();Object b;b=a;这种形式的代码复制的是引用，即对象在内存中的地址，a和b对象仍然指向了同一个对象。而通过clone方法赋值的对象跟原来的对象时同时独立存在的。扯了这么多废话，终于进入正题了ORZ。
如何实现克隆
简单到你不敢相信。直接在你的类的后面声明implements Cloneable。关于这个接口，它的源码如下：
public interface Cloneable {
}
可以看到它是一个空的接口，它的作用就是做标记。如果没有实现Cloneable接口就直接使用clone方法，程序会抛出CloneNotSupportedException异常。
然后是重写clone方法，并修改成public访问级别。举个经典的栗子：
class Outer implements Cloneable {
public int name;
public Inner inner;
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
public static void main(String[] args){
Outer o_one = new Outer();
o_one.inner = new Inner("zhangsan");
try {
Object obj = o_one.clone();
Outer o_two = (Outer)obj;
System.out.println(o_one==o_two); //打印false
System.out.println(o_one.inner.name.equals(o_two.inner.name)); //打印true
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
上面的代码实现的其实是浅克隆，浅克隆对于引用类型仅拷贝引用，没有真正地让两个对象独立开来互相之间没有任何关系。由于是浅克隆，使得imp2修改了child的某个属性后会是的imp1中child的属性也跟着改变。或者比较两个对象的地址：imp1.child==imp2.child，返回的结果是true。但是，如果一个对象只包含原始数据域或者不可变对象域（比如String类型），推荐使用浅克隆。
深克隆
类中的所有引用类型做一些修改，让它也实现Cloneable接口。然后修改本类中的clone方法：
public class Inner implements Cloneable{
public String name;
public Child(String name) {
this.name = name;
}
@Override
public String toString() {
return "Inner的name值为：" + name;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
修改本类的clone方法：
static class Outer implements Cloneable {
public int count;
public Inner inner;
@Override
public Object clone() throws CloneNotSupportedException {
Outer obj = (Outer)super.clone();
obj.inner = (Inner) inner.clone();
return obj;
}
}
画重点了：
- 需要重写clone方法，不仅仅只调用父类的方法，还需调用属性的clone方法；
- 对象之间100%数据分离
- 如果是对象存在引用类型的属性，建议使用深克隆
- 深克隆比浅克隆要更加耗时，效率更低
解决多层克隆问题
如果引用类型里面还包含很多引用类型，或者内层引用类型的类里面又包含引用类型，使用clone方法就会很麻烦。这时我们可以用序列化的方式来实现对象的深克隆。
public class Outer implements Serializable{
private static final long serialVersionUID = 369285298572941L; //最好是显式声明ID
public Inner inner;
public Outer myclone() {
Outer outer = null;
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this);
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
outer = (Outer) ois.readObject();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return outer;
}
}
Inner也必须实现Serializable，否则无法序列化：
public class Inner implements Serializable{
private static final long serialVersionUID = 872390113109L; //最好是显式声明ID
public String name = "";
public Inner(String name) {
this.name = name;
}
@Override
public String toString() {
return "Inner的name值为：" + name;
}
}
这样也能使两个对象在内存空间内完全独立存在，互不影响对方的值。
Tips
- 在克隆方法中，如果我们需要对可变对象的final域也进行拷贝，由于final的限制，所以实际上是无法编译通过的。因此为了实现克隆，我们需要考虑舍去该可变对象域的final关键字。
- 如果你决定用线程安全的类实现Cloneable接口，需要保证它的clone方法做好同步工作。默认的Object.clone方法是没有做同步的。
