java的clone()、浅拷贝与深拷贝

clone()方法是Object的native方法。protected native Object clone() throws CloneNotSupportedException; 声明为protected，表明子类必须重新实现该方法，除非是与Obeject类在一个包里，后者是不可能的。而实际上，作为native方法clone()已经有一份field to field的浅拷贝实现，实际上是不需要一定重写的。这种情况下，需要的做法就是覆写clone()方法，在方法里通过super.clone()调用Object的clone()。

而Cloneable是标记型接口，实现了Cloneable才可以实现clone()方法。否则使用clone()方法会报错。

下面是ArrayList的clone()

/**
* Returns a shallow copy of this <tt>ArrayList</tt> instance.  (The
* elements themselves are not copied.)
*
* @return a clone of this <tt>ArrayList</tt> instance
*/
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}

这里为何不是简单的super.clone()浅拷贝呢？因为成员变量是复杂类型时(涉及成员变量为对象的引用)，就需要深拷贝。

下面做个小实验，先使用浅拷贝，验证普通的成员变量是ok的：

package a;

public class CloneTest  implements Cloneable {
private int v_a;
public void setV_a(int v) {
v_a = v;
}
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
public void print_v_a() {
System.out.println(v_a);
}
public static void main(String[] args) throws CloneNotSupportedException {
CloneTest ct0 = new CloneTest();
ct0.setV_a(66);
CloneTest ct1 = (CloneTest)ct0.clone();
ct1.print_v_a();
ct0.setV_a(88);
ct1.print_v_a();
ct0.print_v_a();
}
}

先设置ct0的v_a对象为66，然后ct1对象是ct0的拷贝，打印ct1的v_a，也为66，说明拷贝成功。 之后重新设置ct0的值为88，ct1的值没变还是66。

package a;

import java.util.Arrays;

class A {
private int v;
public void setV(int v) {
this.v = v;
}
public void p_v() {
System.out.println(v);
}
}

public class CloneTest  implements Cloneable {
private A v_a;
public void setV_a(A v) {
v_a = v;
}
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
public void print_v_a() {
v_a.p_v();
}
public static void main(String[] args) throws CloneNotSupportedException {
CloneTest ct0 = new CloneTest();
A a = new A();
a.setV(66);
ct0.setV_a(a);
CloneTest ct1 = (CloneTest)ct0.clone();
ct1.print_v_a();
a.setV(88);
ct0.setV_a(a);
ct1.print_v_a();
}
}

上面这个例子就体现出了浅拷贝的弱点，输出为66 88。

ct1是浅拷贝的ct0，此时ct0的v_a(成员变量，A对象)的v值为66。拷贝后，ct1的v_a(A对象的v)输出也是66。然后重设ct0的v_a(A对象的v)为88，再输出ct1的v_a(A对象的v)，竟然也是88。说明二者的引用指向的是同样的堆内存。

浅拷贝情况下，两个对象的成员变量(A对象)引用的是同一个堆内存，并没有完全实现拷贝后内存独立。

这种情况就需要深拷贝。

例如文章最开始提到的ArrayList的clone()的写法。