Java Object对象之clone方法

Posted 2022-11-21 楠来风

克隆的目的：快速创建一个已有对象的副本。

克隆的步骤：

1. 创建一个对象
2. 将原有对象的数据导入到新创建的数据中

1. Object的clone()源代码简介

[java]

  view plain  copy  

1. /** 
2.  * Creates and returns a copy of this @code Object. The default 
3.  * implementation returns a so-called "shallow" copy: It creates a new 
4.  * instance of the same class and then copies the field values (including 
5.  * object references) from this instance to the new instance. A "deep" copy, 
6.  * in contrast, would also recursively clone nested objects. A subclass that 
7.  * needs to implement this kind of cloning should call @code super.clone() 
8.  * to create the new instance and then create deep copies of the nested, 
9.  * mutable objects. 
10.  * 
11.  * @return a copy of this object. 
12.  * @throws CloneNotSupportedException 
13.  *             if this object's class does not implement the @code 
14.  *             Cloneable interface. 
15.  */  
16. protected Object clone() throws CloneNotSupportedException   
17.     if (!(this instanceof Cloneable))   
18.         throw new CloneNotSupportedException("Class doesn't implement Cloneable");  
19.       
20.   
21.     return internalClone((Cloneable) this);  
22.   
23.   
24. /* 
25.  * Native helper method for cloning. 
26.  */  
27. private native Object internalClone(Cloneable o);  

clone方法首先会判对象是否实现了Cloneable接口，若无则抛出CloneNotSupportedException, 最后会调用internalClone. intervalClone是一个native方法，一般来说native方法的执行效率高于非native方法。

当某个类要复写clone方法时，要继承Cloneable接口。通常的克隆对象都是通过super.clone()方法来克隆对象。

2.浅克隆(shadow clone)

   克隆就是复制一个对象的复本.若只需要复制对象的字段值（对于基本数据类型,如:int,long,float等，则复制值；对于复合数据类型仅复制该字段值，如数组变量则复制地址，对于对象变量则复制对象的reference。

例子：

[java]

  view plain  copy  

1. public class ShadowClone implements Cloneable  
2.          
3.     private int a;   // 基本类型  
4.     private int[] b; // 非基本类型  
5.     // 重写Object.clone()方法,并把protected改为public  
6.     @Override  
7.     public Object clone()  
8.         ShadowClone sc = null;  
9.         try  
10.           
11.             sc = (ShadowClone) super.clone();  
12.          catch (CloneNotSupportedException e)  
13.             e.printStackTrace();  
14.           
15.         return sc;  
16.       
17.     public int getA()  
18.       
19.         return a;  
20.       
21.     public void setA(int a)  
22.       
23.         this.a = a;  
24.       
25.     public int[] getB()   
26.     return b;  
27.       
28.     public void setB(int[] b)   
29.     this.b = b;  
30.         
31.   

然后进行测试：

[java]

  view plain  copy  

1. public class Test  
2.     public static void main(String[] args) throws CloneNotSupportedException  
3.         ShadowClone c1 = new ShadowClone();  
4.         //对c1赋值  
5.         c1.setA(100) ;  
6.         c1.setB(new int[]1000) ;  
7.           
8.         System.out.println("克隆前c1:  a="+c1.getA()+" b="+c1.getB()[0]);  
9.         //克隆出对象c2,并对c2的属性A,B,C进行修改  
10.         ShadowClone c2 = (ShadowClone) c1.clone();  
11.         //对c2进行修改  
12.         c2.setA(50) ;  
13.         int []a = c2.getB() ;  
14.         a[0]=5 ;  
15.         c2.setB(a);  
16.         System.out.println("克隆前c1:  a="+c1.getA()+" b="+c1.getB()[0]);  
17.         System.out.println("克隆后c2:  a="+c2.getA()+ " b[0]="+c2.getB()[0]);  
18.       
19.   

结果为：

克隆前c1:  a=100 b=1000
克隆前c1:  a=100 b=5
克隆后c2:  a=50 b[0]=5

c1和c2的对象模型：

                                                                     

可以看出，基本类型可以使用浅克隆，而对于引用类型，由于引用的是内容相同，所以改变c2实例对象中的属性就会影响到c1。所以引用类型需要使用深克隆。另外，在开发一个不可变类的时候，如果这个不可变类中成员有引用类型，则就需要通过深克隆来达到不可变的目的。

3.深克隆(deep clone)

    深克隆与浅克隆的区别在于对复合数据类型的复制。若对象中的某个字段为复合类型，在克隆对象的时候，需要为该字段重新创建一个对象。

例子：

[java]

  view plain  copy  

1. public class DeepClone implements Cloneable   
2.   
3.     private int a;   // 基本类型  
4. java.lang.Object 之 clone() 使用

   java.lang.Object 之 clone() 深拷贝,浅拷贝

   Java的clone()方法

   阿里公约推荐慎用 Object 的 clone 方法来拷贝对象。

   Java中clone方法的使用

   java Object对象的clone方法