关闭

JAVA的Clone

193人阅读 评论(0) 收藏 举报

基本的数据类型可以自动的实现深度的克隆,然而并不是所有的类都可以进行深度的克隆,就比如String类,其类定义为final,且没有重载clone方法,我们就无法完成对String类的深度克隆。但在实际的操作中,因为String的final属性,导致改变复制后的String对象,不影响之前的值,所以,String对于clone方法来说,就相当于基本类型。关于其他不可变对象的克隆,我们通常没有必要去克隆。

1. Overiew

在实际编程中,我们经常会遇到这样一个情景:有一个对象A,存在属性方法,现在需要一个和A完全相同的新对象B,并且B的任何改动都不会影响到A中的值。那么,最常用的办法就是对A进行克隆。

2. How to Clone

在java.lang.Object中有一个clone方法,该方法的签名如下:

Java代码

  1. protected native Object clone() throws CloneNotSupportedException;  

该方法返回一个Object实例的拷贝,该实例拷贝具有:

1)拷贝对象是一个新对象而不是一个原对象引用。

2)拷贝的对象中包含的是原有对象信息,而不是对象初始化的信息(也就是说,拷贝过程没有调用构造函数)。

从第1条我们可以看出,拷贝的对象与原对象存在这样一种关系:

Java代码

  1. 1. x.clone() != x      will be true    
  2. 2. x.clone().getClass() == x.getClass() will be true, but these are not absolute requirements        
  3. 3. x.clone().equals(x) will be true, but these are not absolute requirements    

要实现克隆,必须满足一下三点:

1)类必须实现Cloneable接口

2)类必须重载Object类中的clone()方法

3)重载的clone()方法中,必须显示调用super.clone()。

我们看一下Cloneable接口的定义:

Java代码

  1. public interface Cloneable { }   

Cloneable接口是不包含任何方法的,仅仅表示一个标志(类似Serializable接口),而且这个标志也是针对Object类中clone()方法的,如果clone类没有实现Cloneable接口,并调用了Object的clone()方法(也就是调用了super.Clone()方法),那么Object的clone()方法就会抛出CloneNotSupportedException异常。

按照要求,我们写一个克隆类的小例子:

Java代码

  1. public class DummyClone implements Cloneable{     
  2.     
  3.     public Object clone(){     
  4.         DummyClone dc = null;     
  5.         try {     
  6.             dc = (DummyClone)super.clone();     
  7.         } catch (CloneNotSupportedException e) {     
  8.             e.printStackTrace();     
  9.         }     
  10.         return dc;     
  11.     }     
  12. }   

3. Shadow Clone

首先,我们来看一个例子:ClassA没有实现Cloneable接口。ClassB存在ClassA的实例,实现了Cloneable接口,并重载了clone方法。ClassC实例化一个ClassB对象,然后克隆一个对象。

Java代码

  1. class ClassA {     
  2.          
  3.     public int a;     
  4.          
  5.     public void doubleA(){     
  6.         a = a * 2;     
  7.     }     
  8.          
  9.     public ClassA(int aa){     
  10.         this.a = aa;     
  11.     }     
  12.          
  13.     public String toString(){     
  14.         return Integer.toString(a);     
  15.     }     
  16. }     
  17.     
  18. class ClassB implements Cloneable{     
  19.          
  20.     public int b;     
  21.          
  22.     public ClassA ca = new ClassA(11);     
  23.          
  24.     public Object clone(){     
  25.         ClassB cb = null;     
  26.         try {     
  27.             cb = (ClassB)super.clone();     
  28.         } catch (CloneNotSupportedException e) {     
  29.             e.printStackTrace();     
  30.         }     
  31.         return cb;     
  32.     }     
  33. }     
  34.     
  35. public class ClassC {     
  36.          
  37.     public static void main(String[] args) {     
  38.         ClassB cb = new ClassB();     
  39.         cb.b = 222;     
  40.         System.out.println("before clone : cb.b = " + cb.b);     
  41.         System.out.println("before clone : cb.ca = " + cb.ca);     
  42.              
  43.         //     
  44.         ClassB cb2 = (ClassB)cb.clone();     
  45.         cb2.b = 3333;     
  46.         cb2.ca.doubleA();     
  47.         System.out.println("========================");     
  48.         System.out.println("after clone : cb.b = " + cb.b);     
  49.         System.out.println("after clone : cb.ca = " + cb.ca);     
  50.         System.out.println("========================");     
  51.         System.out.println("after clone : cb2.b = " + cb2.b);     
  52.         System.out.println("after clone : cb2.ca = " + cb2.ca);     
  53.     }     
  54. }    

输出结果如下:

Java代码

  1. before clone : cb.b = 222    
  2. before clone : cb.ca = 11    
  3. ========================     
  4. after clone : cb.b = 222    
  5. after clone : cb.ca = 22    
  6. ========================     
  7. after clone : cb2.b = 3333    
  8. after clone : cb2.ca = 22  

从结果我们看到,int类型的b被完全的克隆了,而ClassA类型的ca却没有被克隆。因为克隆后cb2对b的赋值不会影响原有cb中b的值,而调用cb2.ca.doubleA()方法后,对cb2.ca的改变同时改变了cb.ca,表明cb2.ca与cb.ca仅仅指向同一个对象的不同引用。从中可以看出,调用Object类中clone()方法产生的效果是:先在内存中开辟一块和原始对象一样的空间,然后原样拷贝原始对象中的内容。对基本数据类型,这样的操作是没有问题的,但对非基本类型变量clone后的变量和原始对象中相应的变量指向的是同一个对象。

这就是影子克隆。影子克隆,并没有完整的完成克隆,有时候这并不是我们想要的结果。我们有时需要,就像列子中调用cb2.ca.doubleA()方法时,不会对原对象产生改变,这时候我们就需要deep clone;

4. Deep Clone

要实现深度克隆,在上面的例子基础上,我们只需要这样修改即可:

Java代码

  1. class ClassA implements Cloneable{     
  2.          
  3.     public int a;     
  4.          
  5.     public void doubleA(){     
  6.         a = a * 2;     
  7.     }     
  8.          
  9.     public ClassA(int aa){     
  10.         this.a = aa;     
  11.     }     
  12.          
  13.     public String toString(){     
  14.         return Integer.toString(a);     
  15.     }     
  16.          
  17.     public Object clone(){     
  18.         ClassA ca = null;     
  19.         try {     
  20.             ca = (ClassA)super.clone();     
  21.         } catch (CloneNotSupportedException e) {     
  22.             e.printStackTrace();     
  23.         }     
  24.         return ca;     
  25.     }     
  26. }     
  27.     
  28. class ClassB implements Cloneable{     
  29.          
  30.     public int b;     
  31.          
  32.     public ClassA ca = new ClassA(11);     
  33.          
  34.     public Object clone(){     
  35.         ClassB cb = null;     
  36.         try {     
  37.             cb = (ClassB)super.clone();     
  38.         } catch (CloneNotSupportedException e) {     
  39.             e.printStackTrace();     
  40.         }     
  41.         cb.ca = (ClassA)ca.clone();     
  42.         return cb;     
  43.     }     
  44. }     
  45.     
  46. public class ClassC {     
  47.          
  48.     public static void main(String[] args) {     
  49.         ClassB cb = new ClassB();     
  50.         cb.b = 222;     
  51.         System.out.println("before clone : cb.b = " + cb.b);     
  52.         System.out.println("before clone : cb.ca = " + cb.ca);     
  53.              
  54.         //     
  55.         ClassB cb2 = (ClassB)cb.clone();     
  56.         cb2.b = 3333;     
  57.         cb2.ca.doubleA();     
  58.         System.out.println("========================");     
  59.         System.out.println("after clone : cb.b = " + cb.b);     
  60.         System.out.println("after clone : cb.ca = " + cb.ca);     
  61.         System.out.println("========================");     
  62.         System.out.println("after clone : cb2.b = " + cb2.b);     
  63.         System.out.println("after clone : cb2.ca = " + cb2.ca);     
  64.     }     
  65. }    

输出结果:

Java代码

  1. before clone : cb.b = 222    
  2. before clone : cb.ca = 11    
  3. ========================     
  4. after clone : cb.b = 222    
  5. after clone : cb.ca = 11    
  6. ========================     
  7. after clone : cb2.b = 3333    
  8. after clone : cb2.ca = 22 
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:34791次
    • 积分:526
    • 等级:
    • 排名:千里之外
    • 原创:17篇
    • 转载:30篇
    • 译文:0篇
    • 评论:1条
    最新评论