1
什么是
Clone
，容易实现吗？
简单地说，
Clone
就是对于给定的一个对象实例
o
，得到另一个对象实例
o’
：
o
与
o’
类
型相同（
o.getClass() == o’.getClass()
），内容相同（对于
o/o’
中的字段
f
，如果
f
是基本数据类型，则
o.f == o’.f
；如果
f
是对象引用，则
o.f == o’.f
或
o.f
指向的对象与
o’.f
指向的对象的内容相同）。通常称
o’
为
o
的克隆或副本。
直观上看，似乎很容易为一个类加上
clone
方法：
|
class A {
private Type1 field1;
private Type2 field2;
…..
public Object clone() {
A a = new A();
a.field1 = a.getField1();
a.field2 = a.getField2();
……
return a;
}
}
|
然而，稍加推敲，就会发现这样的实现方法有两个问题：
1.
要想某个类有
clone
功能，必须单独为其实现
clone()
函数，函数实现代码与该类定义密切相关。
2.
即使基类
A
已有
clone()
函数，其子类
ExtendA
若要具备
clone
功能，则必须
override
其基类
A
的
clone()
函数。否则，对类型为
ExtendA
的对象
ea
的
clone()
方法的调用，会执行于类
A
中定义的
clone()
方法而返回一个类型为
A
的对象，它显然不是
ea
的克隆。
2
Java
对
clone
的支持
万类之初的
Object
类有
clone()
方法：
|
protected native Object clone() throws CloneNotSupportedException;
|
该方法是
protected
的，显然是留待被子类
override
的。该方法又是
native
的，必然做了
与具体平台相关的底层工作。
事实上，类
Object
的
clone()
方法首先会检查
this.getClass()
是否实现了
Cloneable
接口。
Cloneable
只是一个标志接口而已，用来标志该类是否有克隆功能。
|
public
interface
Cloneable {
}
|
如果
this.getClass()
没有实现
Cloneable
接口，
clone()
就会抛
CloneNotSupportedException
返回。否则就会创建一个类型为
this.getClass()
的对象
other
，并将
this
各
field
的值赋值给
other
的对应
field
，然后返回
other
。
如此一来，我们要定义一个具有
Clone
功能的类就相当方便：
1.
在类的声明中加入“
implements Cloneable
”，标志该类有克隆功能；
2.
Override
类
Object
的
clone()
方法，在该方法中调用
super.clone()
：
|
class CloneableClass implements Cloneable {
……
public Object clone() {
try {
return super.clone();
//
直接让
Object.clone()
为我们代劳一切
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
}
}
|
3
Shallow Clone
与
Deep Clone
3.1
Shallow
与
Deep
从何而来
一个具有克隆功能的类，如果有可变（
Mutable
）类类型的字段
field
，如何为其克隆（副
本）对象
o’
中的
field
赋值？
方法一、如
Object
的
clone()
方法所实现：设原始对象为
o
，其克隆对象是
o’
，执行
o’.field = o.field
。这样，
o’.field
与
o.field
指向同一个可变对象
m
。
o
与
o’
可能会相互影响（一个对象的状态可能会随着另一个对象的状态的改变而改变）。这样的
Clone
称为
Shallow Clone
。这也是
Object
的
clone()
方法的实现方式。
方法二、将
o.field
指向的可变对象
m
克隆，得到
m’
，将
m’
的引用赋值给
o’.field
。这样
o’
与
o
内容相同，且相互之间无影响（一个对象状态的改变不会影响另一个对象的状态）。这样的
Clone
称为
Deep Clone
。
Java Collection
类库中具体数据结构类（
ArrayList/LinkedList
，
HashSet/TreeSet
，
HashMap/TreeMap
等）都具有克隆功能，且都是
Shallow Clone
，这样设计是合理的，因为它们不知道存放其中的每个数据对象是否也有克隆功能。
System.arrayCopy()
的实现采用的也是
Shallow Clone
。
Deep Clone
对于实现不可变（
Immutable
）类很有帮助。设一个类包含可变类
M
类型的
field
，如何将其设计为不可变类呢？先为
M
实现
Deep Clone
功能，然后这样设计类
ImmutableClass
：
|
class ImmutableClass {
MutableClass m;
ImmutableClass(MutableClass m) {
this.m = m.clone();
//
将传入的
m
的
clone
赋值给内部
m
}
public MutableClass getM() {
return this.m.clone();
//
将内部
m
的
clone
返回给外部
}
}
|
3.2
如何实现
Deep Clone
检查类有无可变类类型的字段。如果无，返回
super.clone()
即可；
如果有，确保包含的可变类本身都实现了
Deep Clone
；
Object o = super.clone();
//
先执行浅克隆，确保类型正确和基本类型及非可变类类型字段内容正确
对于每一个可变类类型的字段
field
：
o.field = this.getField().clone();
返回
o
。