*

*

     * x.clone().equals(x)

     * will be true, this is not an absolute requirement. 

     *

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

     * super.clone.  If a class and all of its superclasses (except

     * Object) obey this convention, it will be the case that

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

     *

     * By convention, the object returned by this method should be independent

     * of this object (which is being cloned).  To achieve this independence,

     * it may be necessary to modify one or more fields of the object returned

     * by super.clone before returning it.  Typically, this means

     * copying any mutable objects that comprise the internal "deep structure"

     * of the object being cloned and replacing the references to these

     * objects with references to the copies.  If a class contains only

     * primitive fields or references to immutable objects, then it is usually

     * the case that no fields in the object returned by super.clone

     * need to be modified.

     *

     * The method clone for class Object performs a 

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

     * not implement the interface Cloneable, then a 

     * CloneNotSupportedException is thrown. Note that all arrays 

     * are considered to implement the interface Cloneable. 

     * 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.

     *

     * The class Object does not itself implement the interface 

     * Cloneable, so calling the clone method on an object 

     * whose class is Object will result in throwing an

     * exception at run time.

     *

     * @return     a clone of this instance.

     * @exception  CloneNotSupportedException  if the object's class does not

     *               support the Cloneable interface. Subclasses

     *               that override the clone method can also

     *               throw this exception to indicate that an instance cannot

     *               be cloned.

     * @see java.lang.Cloneable

     */

    protected native Object clone() throws CloneNotSupportedException;

}

呵呵，又是一大串的鸡肠，别以为我是来凑字数的，这些都是Sun公司Java开发人员写的技术文章，多看看少说话吧。

没错，又是个native方法，果然是个高深的东西，不过我们还是要占一下他的便宜。而且他这个方法是protected的，分明就是叫我们去占便宜的。

再继续看看下面测试代码。

import java.util.Date;

import org.junit.Test;

public class TestCase {

	@Test

	public void testUserClone() throws CloneNotSupportedException {

		User u1 = new User("Kent", "123456", new Date());

		User u2 = u1;

		User u3 = (User) u1.clone();

		System.out.println(u1 == u2);		// true

		System.out.println(u1.equals(u2));	// true

		System.out.println(u1 == u3);		// false

		System.out.println(u1.equals(u3));	// true

	}

}

这个clone()方法果然牛，一下子就把我们的对象克隆了一份，执行结果也符合我们的预期，u1和u3的地址不同但是内容相同。

Part IV

通过上述的例子，我们可以看出，要让一个对象进行克隆，其实就是两个步骤：

1. 让该类实现java.lang.Cloneable接口；

2. 重写（override）Object类的clone()方法。

但是，事实上真的是如此简单吗？再看下面的代码。

public class Administrator implements Cloneable {

	private User user;

	private Boolean editable;

	public Administrator(User user, Boolean editable) {

		this.user = user;

		this.editable = editable;

	}

	@Override

	protected Object clone() throws CloneNotSupportedException {

		return super.clone();