Object的clone方法

/*Creates and returns a copy of this object. The precise meaning of "copy" may depend on the class of the object. The general intent is that, for any object x, the expression: 

 x.clone() != x
will be true, and that the expression: 
 x.clone().getClass() == x.getClass()
will be true, but these are not absolute requirements. While it is typically the case that: 
 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.
*/
protected native Object clone() throws CloneNotSupportedException;
           

1 下面这些都没有要求必须满足：

            x.clone() != x                                         // 比如在子类的colne方法中return this;

            x.clone().getClass() == x.getClass()        // 子类实现clone方法，可以返没有调用super.clone，而是new了一个子类对象，这时候就不是同一个类

            x.clone().equals(x)                                 // 子类实现colne方法中，如果修改了equals使用的字段，显然不相等

2 按照惯例，子类实现的clone方法应该会调用super.clone()，并且它的父类也都遵守这个约定，那么x.clone().getClass() == x.getClass()  

3 惯例说，本身和克隆应该相互独立，完全两码事，x.clone().equals(x)应该返回false，要达到这个效果：需要在调用 super.clone()之后，修改克隆对象包含的可变对象引用，这些可变对象需要深拷贝。

4 如果一个类只包含不可变对象和原生类型，那么在调用super.clone()之后不需要修改字段。

5  实现clone功能的CloneClass类实现了Cloneable接口，否则会抛出CloneNotSupportedException。

6 重载了clone()方法。最后在clone()方法中调用了super.clone()，这也意味着无论clone类的继承结构是什么样的，super.clone()直接或间接调 用了java.lang.Object类的clone()方法。下面再详细的解释一下这几点。 应该说第三点是最重要的，仔细观察一下Object类的clone()一个native方法，native方法的效率一般来说都是远高于java中的非 native方法。这也解释了为什么要用Object中clone()方法而不是先new一个类，然后把原始对象中的信息赋到新对象中，虽然这也实现了 clone功能。对于第二点，也要观察Object类中的clone()还是一个protected属性的方法。这也意味着如果要应用clone()方法，必须继承Object类，在Java中所有的类是缺省继承Object类的，也就不用关心这点了。

7 为了让其它类能调用这个clone类的clone()方法，重载之后要把clone()方法的属性设置为public。 、