JAVA的克隆

什么是"clone"

　　在实际编程过程中，我们常常要遇到这种情况：有一个对象A，在某一时刻A中已经包含了一些有效值，此时可能会需要一个和A完全相同新对象B，并且此后对B任何改动都不会影响到A中的值，也就是说，A与B是两个独立的对象，但B的初始值是由A对象确定的。在Java语言中，用简单的赋值语句是不能满足这种需求的。要满足这种需求虽然有很多途径，但实现clone（）方法是其中最简单，也是最高效的手段。

　　Java的所有类都默认继承java.lang.Object类，在java.lang.Object类中有一个方法clone()。JDK API的说明文档解释这个方法将返回Object对象的一个拷贝。要说明的有两点：一是拷贝对象返回的是一个新对象，而不是一个引用。二是拷贝对象与用new操作符返回的新对象的区别就是这个拷贝已经包含了一些原来对象的信息，而不是对象的初始信息。

代码范例：

class CloneB implements Cloneable{

    public int bi = 99;

    public String bs;

    public UnCloneA ua = new UnCloneA("original_a",111);

    public Object clone(){

        CloneB o = null;

        try{

            o = (CloneB)super.clone();

        }catch (CloneNotSupportedException e) {

            e.printStackTrace();

        }

        return o;

    }

}

　　有三个值得注意的地方，一是希望能实现clone功能的类要实现了Cloneable接口，这个接口是个标识接口，没有需要实现的方法。另一个值得请注意的是覆盖了clone()方法，并且要留意的是clone()方法是继承自Object的，此方法在Object中是protect的，只能被子类调用。我们实现某个类的克隆功能时就要覆盖这个方法，实现起来很简单的，就是调用super.clone(),具体的克隆工作交给Object。

"影子clone"和"深度clone"

代码范例：

public class CloneTest {

    public static void main(String[] a){

        CloneB b1 = new CloneB();

        b1.bs = "original_b";

        System.out.println("before clone,b1.aStr------>" + b1.bs);

        System.out.println("before clone,b1.bi------>" + b1.bi);

        System.out.println("before clone,b1.unCA------>" + b1.ua);

       

        CloneB b2 = (CloneB)b1.clone();

        b2.bs = "clone_b";

        b2.ua.change();

        b2.ua.mul(3);

        System.out.println("after clone,b1.bs------>" + b1.bs);

        System.out.println("after clone,b1.bi------>" + b1.bi);

        System.out.println("after clone,b1.ua------>" + b1.ua);

        System.out.println("after clone,b2.bs------>" + b2.bs);

        System.out.println("after clone,b2.bi------>" + b2.bi);

        System.out.println("after clone,b2.ua------>" + b2.ua);

       

    }

}

 

class UnCloneA implements Cloneable{

    public int ai = 100;

    public String as;

    public UnCloneA(String as,int ai){

        this.as = as;

        this.ai = ai;

    }

    public void change(){

        as = "cloned_" + as;

    }

    public void mul(int i){

        ai = i*ai;

    }

    public String toString(){

        return as + "@" + ai;

    }

//  public Object clone(){

//      UnCloneA o = null;

//      try{

//          o = (UnCloneA)super.clone();

//      }catch (CloneNotSupportedException e) {

//          e.printStackTrace();

//      }

//      return o;

//  }

}

 

class CloneB implements Cloneable{

    public int bi = 99;

    public String bs;

    public UnCloneA ua = new UnCloneA("original_a",111);

    public Object clone(){

        CloneB o = null;

        try{

            o = (CloneB)super.clone();

//          o.ua = (UnCloneA)ua.clone();

        }catch (CloneNotSupportedException e) {

            e.printStackTrace();

        }

        return o;

    }

}

执行结果：

before clone,b1.aStr------>original_b

before clone,b1.bi------>99

before clone,b1.unCA------>original_a@111

after clone,b1.bs------>original_b

after clone,b1.bi------>99

after clone,b1.ua------>cloned_original_a@333

after clone,b2.bs------>clone_b

after clone,b2.bi------>99

after clone,b2.ua------>cloned_original_a@333

 

把注释去掉后的执行结果：

before clone,b1.aStr------>original_b

before clone,b1.bi------>99

before clone,b1.unCA------>original_a@111

after clone,b1.bs------>original_b

after clone,b1.bi------>99

after clone,b1.ua------>original_a@111

after clone,b2.bs------>clone_b

after clone,b2.bi------>99

after clone,b2.ua------>cloned_original_a@333

         第一次的输出结构表明，修改克隆对象b2的int,String等基本类型时，不会对原始对象b1造成影响。就可以理解为，在堆中以及为这些变量开辟了内存空间，把b1的值导入到b2中了。对比2次的输出结果会发现，第一种情况下修改的b2中的UnCloneA对象对b1造成了影响。这就因为b2中并没有UnCloneA的一个实例，只是简单的复制了一个引用，指向了b1中的UnCloneA实例。这就是影子克隆了。如果向让b2中存放一个真正的UnCloneA实例克隆，那就要进行深度克隆，把代码中的注释去掉即可。