clone 研究

缘起

作为Object的12大基本方法（包括Object构造器）之一，怎么能不好好研究一下呢? 呵呵~

分析

1
protected native Object clone() throws CloneNotSupportedException;

其API注释如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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 and that the return type of the clone method of an array type T[] is 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.

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.

翻译如下

1
2
3
4
5
6
7
8
9
返回对象的一份拷贝，但是"拷贝"二字的精确含义可能根据对象不同而不同. 但是普遍的希望是
1. x.clone()!=x 返回true.（即克隆对象和原对象占据不同的内存地址，不能还占据相同的地址，不然连家都没分，算什么拷贝呢?）
2. x.clone().getClass()==x.getClass() 返回true, 即克隆出来的对象和原对象对应的字节码对象是同一份.
3. x.clone().equals(x)返回true.
但是上述三点都不属于必须的要求.
后面的论述主要讲的是clone是浅拷贝而不是深拷贝. 这个后面详述

Object类本身并不实现Cloneable接口，因此在类为Object的对象上调用clone方法将导致在运行时抛出异常。
在一个对象上调用clone方法，如果此对象的类未实现Cloneable接口，则抛出CloneNotSupportedException。请注意，所有数组都默认实现了Cloneable接口，并且数组类型T []的clone方法的返回类型是T []，其中T是任何引用或基本类型。 对于非数组类型，clone方法创建此对象的类的新实例，并使用该对象的相应字段的内容初始化其所有字段，就像通过赋值一样;这些字段的内容本身不会被克隆。因此，该方法执行该对象的“浅拷贝”，而不是“深拷贝”操作。

clone默认是浅拷贝，而不是深拷贝（其实深拷贝代价比较大，所以基本一般默认都是浅拷贝, 深拷贝要自己递归调用clone实现，这个在JavaScript中也是一样的.）

关于 x.clone().equals(x)返回true未必成立——如果x没有覆写equals方法的话，就等价于 x.clone()==x, 这当然返回的是false啦~ 何以为证? 见下面的例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class gao
{
	public static void main(String[] args) throws CloneNotSupportedException 
	{
		A a=new A(1);
		A b=(A)(a.clone());//高的赋给低的是可以的,低的不能直接赋给高的,必须要强转(当然,强转过程中,即运行时可能异常)
		System.out.println(a.equals(b)); //false,虽然Object.clone是浅复制, 但是A 没有覆写 equals方法，则equals方法就是比较地址. 这个和复制的深浅是两回事
	}
}


class A implements Cloneable //必须实现标记接口Cloneable,不然异常
{
	int a;
	
	public A (int _a)
	{
		a=_a;
	}
	
	public Object clone() throws CloneNotSupportedException
	{
		return super.clone(); //高的赋给低的是可以的,低的不能直接赋给高的,必须要强转(当然,强转过程中,即运行时可能异常)
	}
}

下面再讲一下clone复制的深浅性的问题. 首先开宗明义:

所谓浅拷贝就是一个对象占据的堆内存的内部的引用类型（例如String、Date）指向的别的堆内存不会重新拷贝一份，但是基本类型是会重新拷贝一份的. 所以克隆对象对基本数据类型的属性的更改不会影响到原对象. 但是对引用类型属性的更改会影响到原对象的该属性. 但是对于String 这种不可变的引用类型，浅拷贝其实没问题. 因为不论是克隆对象还是 原对象都不能更改它嘛~ 所以其实大家的String属性（其实就是指针）都指向同一块堆内存是没有问题的. 但是如果可变的话就有问题了，一般这样的话，就要再次调用该引用类型属性的clone方法实现对象深复制. 这一点见最后的例子.

clone 拷贝是浅拷贝，如果要实现深拷贝，要自己递归调用clone实现.

注意到clone方法是protected的，这就意味着我们不能直接调用一个未覆写clone方法的对象的clone方法（否则编译都会报错——clone方法is not visible）. 而且根据上面的API注释，这个对象还必须要实现Cloneable接口（一个没有任何实际方法的标记接口）.

如果我们要调用一个类的对象从Object继承来的clone方法，该类必须满足

  1. 对象的类实现了java.lang.Cloneable接口，不然运行时报CloneNotSupportedException
  2. 对象的类覆写了clone方法，不然编译报错——clone is not visible

关于如何使用clone实现深拷贝，见下面的例子.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Person implements Cloneable    
{    
    private int age; 
    private String name;    
    private Date birth;    
    public Person(int a,String n,Date b){       
        age=a;    
    	name=n;    
    	birth=b;    
    }    
        
    public static void main(String[] args){    
        Person kobe=new Person(33,"kobe",new Date());    
        Person kobe_bak=kobe.clone();    
    }    
    @Override    
    public Object clone(){    
        Person p=(Person)super.clone(); // 重新为克隆对象分配堆内存
        //Date类型的birth域是可变变的，需要对其再次调用克隆（浅拷贝），实现Person对象的深拷贝 
        //Date类实现了Cloneable并且覆写了clone方法，所以直接调用即可实现Date
        p.birth=this.birth.clone();    
        return p;    
    }    
}

上述源码值得玩味的地方在于，第18行实现了对克隆对象p在堆内存中的分配空间. 并且重新复制了age过来. String 只是复制了其引用（浅拷贝），但是因为String是不可变的，所以无所谓啊~ 但是对于Date属性birth就不行了——因为它是可变的，这会导致克隆对象对其birth属性的更改会影响到原对象的birth属性. 这种情况业务上一般是不允许的，所以要再次调用birth的clone方法实现Person的深复制才行. 这样clone出来的对象才是业务上可用的.