浅、深克隆

浅clone复制的是栈的内容，如果你复制对象中存在对其他对象的引用，它只是复制那个引用，而不会去复制引用指向的对象。
也就是如果a是b的浅clone对象，那么你修改a之内的对象的引用，就会造成b的变化，因为他们都指向同一个对象。
深clone就是彻彻底底的做了一个新对象，a，b完全独立。

/**
 * @(#)DeepClone.java
 *
 *
 * @author leo
 * @version 1.00 2008/3/10
 */
import java.io.Serializable;
import java.io.IOException;
import java.io.OptionalDataException;
import java.io.*;

public class DeepClone implements Serializable {

    public DeepClone() {
    }
    
    public Object deepClone() throws IOException, OptionalDataException, ClassNotFoundException {
     ByteArrayOutputStream bo = new ByteArrayOutputStream();
     ObjectOutputStream oo = new ObjectOutputStream(bo);
     
     oo.writeObject(this);
     ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
     ObjectInputStream oi = new ObjectInputStream(bi);
     
     return oi.readObject();
    }
    
    public static void main(String[] args) throws Exception {
     DeepClone dc = new DeepClone();
     DeepClone dc1 = (DeepClone) dc.deepClone();
     
     System.out.println(dc);
     System.out.println(dc1);
    }
}

注意：如果被克隆对象内部含有其他对象的引用，那么这些引用所代表的类也要实现Serializable接口。

实现的方法就是

就是在重写的clone方法中，除了调用super.clone()
还要调用当前引用的clone()
Java code
class A{
  int m;
}

class B
{
  int i;
  A a = new A();
public Object clone() {
    B obj = null;
    try {
      obj = (B)super.clone();
    } catch(CloneNotSupportedException e) {
      e.printStackTrace();
    }
    // 就是这句
    obj.a = (A)obj.a.clone();
    return obj;
  }
}
要记得这两个类要实现cloneAble