java对象如果想被克隆，它对应的类需要implements标志接口Cloneable。如果不重写clone()方法，则在调用clone()方法实现的是浅复制(所有的引用对象保持不变，意思是如果原型里这些对象发生改变会直接影响到复制对象)。重写clone()方法，一般会先调用super.clone()进行浅复制，然后再复制那些易变对象，从而达到深复制的效果。千言万语不如代码：

public class CloneTest implements Cloneable{

private byte[] a = {1, 2, 3, 4};

private byte[] b = {5, 6, 7, 8};

public CloneTest clone() {

CloneTest copy = null;

try {

copy = (CloneTest) super.clone();

copy.a = this.a.clone();

} catch (CloneNotSupportedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return copy;

}

// 习惯用上面

// @Override

// protected Object clone() throws CloneNotSupportedException {

// // TODO Auto-generated method stub

// CloneTest copy = (CloneTest) super.clone();

// copy.a = this.a.clone();

// return copy;

// }

public byte[] getA() {

return this.a;

}

public byte[] getB() {

return this.b;

}

public static void main(String[] args) {

CloneTest original = new CloneTest();

CloneTest cloned = original.clone();

System.out.println("original.a == cloned.a : " + (original.getA() == cloned.getA()));

System.out.println("cloned.a[3] = " + cloned.getA()[3]);

original.getA()[3] = 9;

System.out.println("cloned.a[3] = " + cloned.getA()[3]);

System.out.println("original.b == cloned.b : " + (original.getB() == cloned.getB()));

System.out.println("cloned.b[3] = " + cloned.getB()[3]);

original.b[3] = 10;

System.out.println("cloned.b[3] = " + cloned.getB()[3]);

}

}

original.a == cloned.a : false

cloned.a[3] = 4

cloned.a[3] = 4

original.b == cloned.b : true

cloned.b[3] = 8

cloned.b[3] = 10

super.clone()，这个操作主要是来做一次bitwise copy( binary copy )，即浅拷贝，他会把原对象完整的拷贝过来包括其中的引用。这样会带来问题，如果里面的某个属性是个可变对象，那么原来的对象改变，克隆的对象也跟着改变。所以在调用完super.clone()后，一般还需要重新拷贝可变对象。

调用super.clone()后返回的对象满足以下：

x.clone != x

x.clone.getClass() == x.getClass()

以下摘录R大在知乎的回答：

JavaDoc这段

* The method {@code clone} for class {@code Object} performs a

* specific cloning operation. First, if the class of this object does

* not implement the interface {@code Cloneable}, then a

* {@code CloneNotSupportedException} is thrown. Note that all arrays

* are considered to implement the interface {@code Cloneable} and that

* the return type of the {@code clone} method of an array type {@code T[]}

* is {@code T[]} where T is any reference or primitive type.

* Otherwise, this method creates a new instance of the class of this

* object and initializes all its fields with exactly the contents of

* the corresponding fields of this object, as if by assignment; the

* contents of the fields are not themselves cloned. Thus, this method

* performs a "shallow copy" of this object, not a "deep copy" operation.

也就是说JavaDoc指明了Object.clone()有特殊的语义，他就是能把当前对象的整个结构完全浅拷贝一份出来。

* By convention, the returned object should be obtained by calling

* {@code super.clone}. If a class and all of its superclasses (except

* {@code Object}) obey this convention, it will be the case that

* {@code x.clone().getClass() == x.getClass()}.

每层clone()都顺着 super.clone() 的链向上调用的话最终就会来到Object.clone() ，于是根据上述的特殊语义就可以有 x.clone.getClass() == x.getClass() 。

至于如何实现的，可以把JVM原生实现的Object.clone()的语义想象成拿到this引用后通过反射去找到该对象实例的所有字段，然后逐一字段拷贝。

HotSpot vm中，Object.clone()在不同的优化层级上有不同的实现。在其中最不优化的版本是这样做的：拿到this引用，通过对象头里记录的Klass信息去找出这个对象有多大，然后直接分配一个新的同样大的空对象并且把Klass信息塞进对象头(这样就已经实现了x.clone.getClass() == x.getClass()这部分语义)，然后直接把对象体 的内容看作数组拷贝一样从源对象“盲”拷贝到目标对象，bitwise copy。然后就完事啦。

-----------------------------------------------------------------------------------

我的理解是super.clone() 的调用就是沿着继承树不断网上递归调用直到Object 的clone方法，而跟据JavaDoc所说Object.clone()根据当前对象的类型创建一个新的同类型的空对象，然后把当前对象的字段的值逐个拷贝到新对象上，然后返回给上一层clone() 调用。

也就是说super.clone() 的浅复制效果是通过Object.clone()实现的。