黑马程序员技术交流社区

标题: java克隆机制 [打印本页]
作者: Tking    时间: 2014-4-11 07:09
标题: java克隆机制
java克隆机制
克隆（clone）：创建并返回此对象的一个副本。“副本”的准确含义可能依赖于对象的类。
通俗易懂的说法:将一个已经存在的实例对象，复制成多个实例，而且每个实例对象直接并没有联系，不会改一处，多处改变。也相当于Copy一样。
而克隆机制也分为深克隆（Shallow clone）与浅克隆(Deep clone),下面通过几个实例来演示。
首先：要克隆的类必须实现Cloneable，这是个许可证，么实现该接口，并重写其方法的类不能实现克隆。
1、定义一个类允许克隆。
  1. class Aa implements Cloneable//克隆的前提
  2. {
  3. 　　Int i=1;;
  4. 　　@override//必须实现的方法
  5.         protected Object clone() throws CloneNotSupportedException {
  6.                 return super.clone();
  7. 　　        }
  8. }
  9. public class Demo05 {

  11.         Public static void main(String[] args) throws CloneNotSupportedException {
  12.                 Aa a=new Aa();
  13.                 Aa b=(Aa)a.clone();
  14. 　　Aa c=a;
  15.                 System.out.println(a.i);
  16.                 System.out.println(b.i);
  17.                 System.out.println(c.i);       
  18.         }
  19. }
  20. //运行结果：
  21. 　　1
  22. 　　1
  23. 　　1
复制代码
这样的结果很可能产生两种误会，对有没有过基础的会觉得，把a赋给了b和c。
对了解java指针机制的就会说，b和a都指向了a。两者都只对了一半。
下面增加两行代码就明白了；
  1. 　　Aa a=new Aa();
  2.                 Aa b=(Aa)a.clone();
  3.                 Aa c=a;
  4.                 b.i=10;
  5.                 c.i=5;
  6.                 System.out.println(a.i);
  7.                 System.out.println(b.i);
  8.                 System.out.println(c.i);
  9. //运行结果：
  10. 　　5
  11. 　　10
  12. 　　5
复制代码
显而易见，c变量指向了a，而b变量却是将a变量完全复制过来。很多时候我们都想得到某个对象的副本，暂时修改其属性又不能令对象的属性改变，很矛盾，这是这里可以用到clone关键字，但是这种克隆只能算得上浅度克隆（Shallow Clone）。
什么是深克隆？什么事浅克隆？
实例：在Aa这类中多了一个其他类的对象
  1. class Aa implements Cloneable
  2. {
  3.         int i=1;
  4.         B field=new B();
  5.         @Override
  6.         protected Object clone() throws CloneNotSupportedException {
  7.                 return super.clone();
  8.         }
  9. }
  10. class B
  11. {
  12.         int i=1;
  13.         public int getI() {
  14.                 return i;
  15.         }
  16.         public void setI(int i) {
  17.                 this.i = i;
  18.         }
  19. }
  20. //然后主程序依旧按照常规克隆；
  21. 　　Aa a=new Aa();
  22.                 Aa b=(Aa)a.clone();
  23.                 b.field.setI(10);
  24.                 System.out.println(a.field.getI());
  25.                 System.out.println(b.field.geitI());
  26. //运行结果：
  27. 　　10
  28. 　　10
复制代码
结果出乎意料，咋么又变成指针机制了？
要知道这些，先要了解Object在调用clone方法的时候都做了些什么。
Object在对某个实施Clone时对其对象一无所知，仅仅只是简单的做了一个Copy的动作，这就是浅克隆。但是在Aa类中却有一个引用型变量，当克隆时候，就把该对象的地址给克隆了，并没有克隆出实力对象。也可以验证下。
  1. 　　System.out.println(a);
  2.                 System.out.println(b);
  3.                 System.out.println(a.field);
  4. 　　        System.out.println(b.field);
  5. //运行结果：
  6. 　　Aa@7800e9
  7. 　　Aa@83dae1
  8. 　　B@971d55
  9. 　　B@971d55
复制代码
结果说明，a和b不是同一个对象，但是a对象的成员field与b对象的成员field，却是同一个对象，如图：

从图上可以看出，基本类型被克隆了，但是引用类型变量，却只克隆了地址，这种克隆也称作浅克隆（Shallow Clone）
怎么才能做到深度度克隆呢？
其实很简单，只需要重新定义Clone方法，对B类做特殊处理（Deep Clone）深度克隆；
  1. class Aa implements Cloneable
  2. {
  3.         int i=1;
  4.         B field=new B();
  5.         @Override
  6.         protected Object clone() throws CloneNotSupportedException {
  7.                 Aa temp=(Aa)super.clone();//先克隆主体
  8.                 temp.field=(B)field.clone();//再克隆引用
  9.                 return temp;
  10.         }
  11. }
  12. class B implements Cloneable//这个类也要实现克隆标记
  13. {
  14.         int i=1;
  15.         public int getI() {
  16.                 return i;
  17.         }
  18.         public void setI(int i) {
  19.                 this.i = i;
  20.         }
  21. 　　//还要重写克隆方法
  22.         protected Object clone() throws CloneNotSupportedException {
  23.                
  24.                 return super.clone();
  25.         }
  26. }
  27. //这时候在打印：
  28. public static void main(String[] args) throws CloneNotSupportedException {
  29.                 Aa a=new Aa();
  30.                 Aa b=(Aa)a.clone();
  31.                 b.field.setI(100);
  32.                 b.i=10;
  33.                 System.out.println(a.i);
  34.                 System.out.println(b.i);
  35.                 System.out.println(a.field.getI());
  36.                 System.out.println(b.field.getI());
  37.         }
  38. //运行结果：
  39. 　　1
  40. 　　10
  41. 　　1
  42. 　　100
复制代码
现在的就够就是这样的：

这样就可以达到预想的效果，两个实例直接没有关系了。
总结：
Clone机制：存在两种方式。
1、Shallow Clone;这种clone只对基本数据类型有效，对对象内的引用变量无效。
2、Deep Clone；对对象所有成员都有效，前提是这些成员都实现了Cloneable接口
3、使用Clone将会抛出异常。
4、两种方式按自己需求而用，



作者: Tking    时间: 2014-4-11 10:23
看帖，要回帖呀，不回帖，写着好没动力:Q



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2