Java对象浅克隆、深克隆及序列化

这里我们就可以引入两个专业的术语：浅克隆（shallow clone）和深克隆（deep clone）。

所谓的浅克隆，顾名思义就是很表面的很表层的克隆，如果我们要克隆Administrator对象，只克隆他自身以及他包含的所有对象的引用地址。而深克隆，就是非浅克隆。克隆除自身以外所有的对象，包括自身所包含的所有对象实例。至于深克隆的层次，由具体的需求决定，也有“N层克隆”一说。但是，所有的基本（primitive）类型数据，无论是浅克隆还是深克隆，都会进行原值克隆。毕竟他们都不是对象，不是存储在堆中。（Java中所有的对象都是保存在堆中，而堆是供全局共享的。也就是说，如果同一个Java程序的不同方法，只要能拿到某个对象的引用，引用者就可以随意的修改对象的内部数据。）

要让一个对象进行克隆，其实就是两个步骤：1. 让该类实现java.lang.Cloneable接口；2. 重写（override）Object类的clone()方法。（并且在方法内部调用持有对象的clone()方法；如果有N多个持有的对象，那就要写N多的方法，突然改变了类的结构，还要重新修改clone()方法。）

public class CloneBean implements Serializable,Cloneable{
 private String st1 ;
 private int i;
 
 public String getSt1() {
  return st1;
 }
 public void setSt1(String st1) {
  this.st1 = st1;
 }
 public int getI() {
  return i;
 }
 public void setI(int i) {
  this.i = i;
 }
 
 //可以实现自身的 值克隆  ，如果在父类的克隆的时候， 显示的调用自身的克隆，并复制给
 @Override
 public Object clone() {
  CloneBean cb = null;
  try {
   cb = (CloneBean) super.clone();//要调用 父类的 clone方法
  } catch (CloneNotSupportedException e) {
   e.printStackTrace();
  }
  return cb;
 }
}

 

public class ShallowClone implements Cloneable {
 // 基本类型  每个对象一份
 private int a;
 private String b;
 
 // 非基本类型  数组 对象， 复制的对象保持一个引用，相关的修改都会影响
 private int[] c;
 private CloneBean clonebean;
 
 // 重写Object.clone()方法,并把protected改为public    《只是浅克隆， 如果要实现真正的深克隆，用到 序列化及反序列化》
 @Override
 public Object clone() {
  ShallowClone sc = null;
  try {
   sc = (ShallowClone) super.clone();//要调用 父类的 clone方法
  } catch (CloneNotSupportedException e) {
   e.printStackTrace();
  }
  
  //sc.clonebean=(CloneBean)clonebean.clone();  显示的调用 对象的克隆，也可以保持对象的新值，因为 本身对象又是一个新的对象
  
  return sc;
 }

 public int getA() {
  return a;
 }

 public void setA(int a) {
  this.a = a;
 }

 public String getB() {
  return b;
 }

 public void setB(String b) {
  this.b = b;
 }

 public int[] getC() {
  return c;
 }

 public void setC(int[] c) {
  this.c = c;
 }

 public CloneBean getClonebean() {
  return clonebean;
 }

 public void setClonebean(CloneBean clonebean) {
  this.clonebean = clonebean;
 }

}

 

public class ShallowCloneTest {
 public static void main(String[] args) throws CloneNotSupportedException {
  ShallowClone c1 = new ShallowClone();
  // 对c1赋值
  c1.setA(100);
  c1.setB("clone1");
  c1.setC(new int[] { 1000 });
  CloneBean cb = new CloneBean();
  cb.setI(10);
  cb.setSt1("str1");
  c1.setClonebean(cb);

  System.out.println("克隆前: c1.a=" + c1.getA());
  System.out.println("克隆前: c1.b=" + c1.getB());
  System.out.println("克隆前: c1.c[0]=" + c1.getC()[0]);
  System.out.println("克隆前: c1.cb.str1=" + c1.getClonebean().getSt1());
  
  System.out.println("-----------");

  // 克隆出对象c2,并对c2的属性A,B,C进行修改
  ShallowClone c2 = (ShallowClone) c1.clone();
  // 对c2进行修改
  c2.setA(50);
  c2.setB("clone2");
  int[] a = c2.getC();
  a[0] = 500;
  c2.setC(a);
  
  CloneBean cb1 = c2.getClonebean();
  cb1.setSt1("tewtstewt");
  c2.setClonebean(cb1);

  System.out.println("克隆后: c1.a=" + c1.getA());
  System.out.println("克隆后: c1.b=" + c1.getB());
  System.out.println("克隆后: c1.c[0]=" + c1.getC()[0]);
  System.out.println("克隆后: c1.cb.str1=" + c1.getClonebean().getSt1());
  System.out.println("---------------");

  System.out.println("克隆后: c2.a=" + c2.getA());
  System.out.println("克隆后: c2.b=" + c2.getB());
  System.out.println("克隆后: c2.c[0]=" + c2.getC()[0]);
  System.out.println("克隆后: c2.cb.str1=" + c2.getClonebean().getSt1());
 }
}

×××××××××××××××××××××用serializable来实现×××××××××××××××××××××××××××××××××××

//前提是对象以及对象内部 所有引用到的对象 都是可串行化的，否则，就需要仔细考察那些不可串行化的对象可否设成transient，从而将之排除在复制过程之外。而类变量 是全局的，也不作序列化操作。
public class DeepClone implements Serializable
{
 private static final long serialVersionUID = -4371342386287259388L;
 
    private  transient String transi;//修饰为不可瞬时的 不可序列化对象
 public static int k;
 
 private int a;
    private String b;
   
    private int[] c;
    private CloneBean cb;//必须也是可串行化的
   
    public int getA()
    {
        return a;
    }
    public void setA(int a)
    {
        this.a = a;
    }
    public String getB()
    {
        return b;
    }
    public void setB(String b)
    {
        this.b = b;
    }
    public int[] getC()
    {
        return c;
    }
    public void setC(int[] c)
    {
        this.c = c;
    }
 public CloneBean getCb() {
  return cb;
 }
 public void setCb(CloneBean cb) {
  this.cb = cb;
 }
 public String getTransi() {
  return transi;
 }
 public void setTransi(String transi) {
  this.transi = transi;
 }
 public static int getK() {
  return k;
 }
 public static void setK(int k) {
  DeepClone.k = k;
 }

 // 用序列化与反序列化实现深克隆
 public Object deepClone() {
  Object o = null;
  try {
   ByteArrayOutputStream baos = new ByteArrayOutputStream();
   ObjectOutputStream oos = new ObjectOutputStream(baos);
   oos.writeObject(this);
   oos.close();
   ByteArrayInputStream bais = new ByteArrayInputStream(baos
     .toByteArray());
   ObjectInputStream ois = new ObjectInputStream(bais);
   o = ois.readObject();
   ois.close();
  } catch (IOException e) {
   e.printStackTrace();
  } catch (ClassNotFoundException e) {
   e.printStackTrace();
  }
  return o;
 }
   
}

// 所有的对象 都必须 实现 序列化接口
public class DeepCloneTest {
 public static void main(String[] args) throws CloneNotSupportedException
    {
        DeepClone dc1 = new DeepClone();
        // 对dc1赋值
        dc1.setA(100);
        dc1.setB("clone1");
        dc1.setC(new int[] { 1000 });
        CloneBean cb = new CloneBean();
        cb.setSt1("deepClone...before...");
        dc1.setCb(cb);
       
        dc1.setTransi("transiant before");
        DeepClone.k=100;
       
        System.out.println("克隆前: dc1.a=" + dc1.getA());
        System.out.println("克隆前: dc1.b=" + dc1.getB());
        System.out.println("克隆前: dc1.c[0]=" + dc1.getC()[0]);
        System.out.println("克隆前: dc1.cd.str1=" + dc1.getCb().getSt1());
       
        System.out.println("克隆前: dc1.transiant=" + dc1.getTransi());
        System.out.println("克隆前: dc1.k=" + DeepClone.k);
       
        System.out.println("-----------");
        //序列化的所有对象 都要 实现 序列化接口
        DeepClone dc2 = (DeepClone)dc1.deepClone();
        // 对c2进行修改
        dc2.setA(50);
        dc2.setB("clone2");
        int[] a = dc2.getC();
        a[0] = 500;
        dc2.setC(a);
        CloneBean cb2 = dc2.getCb();
        cb2.setSt1("deepClone...after...");
        dc2.setCb(cb2);
       
        System.out.println(dc2.getTransi());    //null值 没有进行复用
        System.out.println(DeepClone.k);         //静态代码块 不用串行化，本身就是公用一块区域
        dc2.setTransi("transiant after");
        DeepClone.k=200;
       
        System.out.println("克隆前: dc1.a=" + dc1.getA());
        System.out.println("克隆前: dc1.b=" + dc1.getB());
        System.out.println("克隆前: dc1.c[0]=" + dc1.getC()[0]);
        System.out.println("克隆前: dc1.cd.str1=" + dc1.getCb().getSt1());
        System.out.println("克隆前: dc1.transiant=" + dc1.getTransi());
        System.out.println("克隆前: dc1.k=" +  DeepClone.k);
       
        System.out.println("-----------");
        System.out.println("克隆后: dc2.a=" + dc2.getA());
        System.out.println("克隆后: dc2.b=" + dc2.getB());
        System.out.println("克隆后: dc2.c[0]=" + dc2.getC()[0]);
        System.out.println("克隆后: dc1.cd.str1=" + dc2.getCb().getSt1());
        System.out.println("克隆后: dc2.transiant=" + dc2.getTransi());
        System.out.println("克隆后: dc2.k=" +  DeepClone.k);
    }
}