Java解析函数_java clone()函数的解析

Clone基本知识储备

clone技术，就不能不提java.lang.Cloneable接口和含有clone方法的Object类。所有具有clone功能的类都有一个特性，那就是它直接或间接地实现了Cloneable接口。否则，我们在尝试调用clone()方法时，将会触发CloneNotSupportedException异常。下面我们通过对Object类的部分源码的分析，来发现和理解这一特性。请看JDK中Object# clone()方法的源码：

protected native

Object clone() throws CloneNotSupportedException;

这段源码的@exception部分的描述内容证实了上文关于clone对象特性论断的正确性。它明确指出对象类必须支持Cloneable接口，否则即使派生类覆盖了Object#clone()方法，也同样会抛出CloneNotSupportedException这个异常。

对于java-api，是这样描述的：

x.clone()!=x的意思是x.clone()返回的对象为新建的对象，与原来的对象地址不同。

x.clone().getClass() ==

x.getClass()的意思是克隆出的对象与原对象都是同一个类生成的。

x.clone().equals(x)的意思是新的对象与原来的对象相同(在equals()函数下是相同的,所以通常需要覆盖equals()方法，但是在下面的例子里，这句话的返回是false)

lclone的实现

1.实现Cloneable接口

通过上一篇的介绍，我们知道，一个类若要具备clone功能，就必须实现Cloneable接口。做到这一步，clone功能已经基本实现了。Clone功能对我们来说，最主要的还是要能够使用它。那么我们如何才能使用clone功能呢？答案是覆盖Object#clone()方法。

2.覆盖Object#clone()方法

为什么需要覆盖Object#clone()方法？这里得再次从jdk源码说起。JDK中Object# clone()方法的原型是：

protectednative Object clone() throws

CloneNotSupportedException;

是否注意到，这里clone()方法修饰符是protected，而不是public。这种访问的不可见性使得我们对Object#clone()方法不可见。相信读者已明白为什么要覆盖Object#clone()方法。而且，覆盖的方法的修饰符必须是public，如果还保留为protected，覆盖将变得没有实际意义。下面举一个具有clone功能的简单的例子：

public class CloneableObjExample implements

Cloneable {

//……部分代码已省略……

Point p2 = (Point)

p1.clone();

public

Object clone() throws

CloneNotSupportedException {

//

call父类的clone方法

Object result = super.clone();

return result;

}

}

3.定制clone

至此，clone已经真相大白。Clone的对象我们可以对其进行定制。还就上面的例子来说。下面的方法对功能做了一定的增强：

public

Object clone() throws

CloneNotSupportedException {

//

call父类的clone方法

CloneableObjExampleresult =

(CloneableObjExample)super.clone();

//TODO:定制clone数据

//虽然”clone”了，但还可以做点调整

result.x= 1;

result.y= 90;

return result;

}

Clone通常有两种类型即浅clone和深clone。首先，分析一下两种的不同。浅clone和深clone都是clone，它们本质区别是对象内部的成员属性(非原生类型属性，如int等)在clone时是否处理为引用。如果仍然保留为引用，则称为浅clone，反之称为深clone。其实这两个概念也是相对的概念。在处理上它们有点区别，浅clone方式得到clone对象即可，深clone方式在得到clone对象后，还需要对引用的成员属性进行“clone”处理。从这个层次上说，深clone并没有什么特别地困难，简单讲就是创建好对象，再设置一些成员属性。关于深clone，网上的文章已经有太多，有点目不暇接的感觉，本文不再赘述，这也不是本文的重点。

本文的重点是要阐述纵深clone，亦即“N深clone”。深到什么程度为止？本文描述的目标是一直深到你想要的程度，包括深到不能再深的程度。

实现方案为采用java reflection技术和递归相结合。

大致步骤描述如下：首先采用java reflection技术动态获取成员方法列表。然后视clone的深度，对具备clone条件的并且有必要clone的成员进行逐一clone。这是一个递归的过程，直到clolne深度已到为止或者到对象已经没有需要clone的成员属性为止。

何为具备clone条件的并且有必要clone的成员进行逐一clone？比如，原生类型(primitive type)，定为瞬态(Transient)的类型，不可访问的类型(!Field#isAccessible())，没实现Cloneable接口的类型等等，都不具备clone条件。String等java定义的类型就不需要再深入clone了，这些属于没必要进行clone的情况。但List类型等“容器”类是有必要clone的成员类型。

据此，递归程序示意如下(deepClone为java方法)：

public Object deepClone(Object obj, int length)

{

Object

result = obj;

//此处为伪代码： 如果对象obj不具备clone条件，就返回result，这也是递归的结束条件。

//此处为伪代码： 如果对象obj没必要clone，就返回result

//此处为伪代码：开始进行“clone”对象。这地方是调一个抽象方法来处理，这样可以增加很多灵活性。该方法主要目的是实现“clone”对象方案。注意：这里面的“clone”方案可能是我们想都想不到的方案，它可能有很多创意，但效果都是一样的，就是要“clone”个新的对象出来。当然最容易想的就是Object#clone()方法了。示意如下：

result

= om.clone(obj);

//此处为伪代码： 获取具备clone条件的并且有必要clone的所有成员。这地方也是调一个抽象方法来处理。同样是为了增强灵活性。获取这些成员的方法有很多，可能是通过setter和getter对来得到，也可能是通过get fields等等方法得到(这种方法可能不少成员是无法直接访问的，往往需要结合别的方法)，甚至是多种方法的综合。总之，目的只有一个，就是获得这些成员。

for

(int i = 0; i < fields.length; i++)

{

//对成员进行处理

//如果已不需要再判断成员了，那除了“容器”成员外，已经clone结束

if

(length <= 1) {

if

(!“容器”成员) {

continue;

}

try

{

//只需clone一次了，注意递归方法的深度参数传入1

clonedFieldValue

= deepClone(“容器”成员的值, 1);

}

catch (Exception ex2) {

ex2.printStackTrace();

return

result;

}

}

else {

try

{

clonedFieldValue

= deepClone(成员的值,

length - 1);

}

catch (Exception ex) {

ex.printStackTrace();

return

result;

}

}

try

{

//此处为伪代码：将clone好的值(clonedFieldValue)设进去

}

catch (Exception ex) {

ex.printStackTrace();

return

result;

}

}//for..

return

result;

}

至此，已完成了“N深clone”。下面讨论一下别的相关问题。比如说这种深度clone原本是A-->B-->C--……-->xz这样一种情况，就是说A类含有B成员，B里面又含有C成员，依此类推。如果想在“N深clone”时，只clone“xz”这个成员怎么办？其实很简单，这个问题主要是要解决在递归过程中有些成员需要clone同时有些成员不需clone仍保留引用这个问题。在上面的递归示例中已经提到，实现“clone”的“方案”已经被定义成抽象方法，那么我们只要对这个方法做一个满足这个需求的实现即可。

对于浅克隆和深克隆

Shallow Clone 与 Deep

Clone

一个具有克隆功能的类，如果有可变( Mutable )类类型的字段 field ，如何为其克隆(副

本)对象 o’ 中的 field 赋值？

方法一、如 Object 的 clone() 方法所实现：设原始对象为 o ，其克隆对象是 o’ ，执行 o’.field =

o.field 。这样， o’.field 与 o.field 指向同一个可变对象 m 。 o与 o’ 可能会相互影响(一个对象的状态可能会随着另一个对象的状态的改变而改变)。这样的 Clone 称为 Shallow

Clone 。这也是 Object 的 clone() 方法的实现方式。

比如看一下的例子：

Point p1；

p1.x = 22;

Point p2 = (Point)

p1.clone();

p2.x  = p1.x;

改变p1.x的值，p2.x的值也变

方法二、将 o.field 指向的可变对象 m 克隆，得到 m’ ，将 m’ 的引用赋值给 o’.field 。这样 o’ 与 o 内容相同，且相互之间无影响(一个对象状态的改变不会影响另一个对象的状态)。这样的 Clone 称为 Deep

Clone 。

比如下面这个例子

Point p2 = (Point)

p1.clone();

p1.x

=23;

Point p3 =

p2;

System.out.print(p1.x+"

"+p2.x+" "+p3.x);

输出23 22

22

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 返回给外部

}

}