java-clone、Serializable

 clone

public class TempClazz {
  public static void main(String[] args) throws CloneNotSupportedException {
    A original = new A();
    original.a = 1;
    original.b = new B();
    original.b.b = 2;
    A clone = (A) original.clone();
    clone.a = 3;
    clone.b.b = 4;
    System.out.println("original: " + original);
    System.out.println("clone: " + clone);
  }

  private static class A implements Cloneable{
    private int a;
    private B b;

    @Override
    protected Object clone() throws CloneNotSupportedException {
      return super.clone();//Object的clone方法为native方法
    }

    @Override
    public String toString() {
      return "A{" +
              "a=" + a +
              ", b=" + b +
              '}';
    }
  }
  private static class B {
    private int b;

    @Override
    public String toString() {
      return "B{" +
              "b=" + b +
              '}';
    }
  }
}

输出

original: A{a=1, b=B{b=4}}
clone: A{a=3, b=B{b=4}}

由输出可知，Object.clone()是浅赋值，只会复制最外层的基础类型和引用（会复制transient字段，类字段不需要复制），并且只需要最外层类实现标记接口Cloneable即可。

当然，可以实现自己的clone方法，最简单的就是返回对象本身，不使用Object.clone()就不必实现Cloneable接口了。

@Override
protected Object clone() throws CloneNotSupportedException {
  return this;
}

如果要实现深度复制，可以使用序列化工具，先将对象序列化，然后再反序列化，比如json，也可以实现自己的深度复制逻辑，创建一个新实例，递归遍历字段进行赋值。

Serializable

public void SerializableTest() throws IOException, ClassNotFoundException {
  ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
  ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
  SerA serA = new SerA();
  serA.a = 1;
  serA.b = new B();
  serA.b.b = 2;
  serA.c = 3;
  serA.d = 4;
  objectOutputStream.writeObject(serA);
  objectOutputStream.close();
  
  serA.c = 9;
  ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
  ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
  Object object = objectInputStream.readObject();
  System.out.println(object);
  objectInputStream.close();
}
   
private static class SerA implements Serializable {
  
  private int a;
  private B b;
  private static int c;
  private transient int d;

  @Override
  public String toString() {
    return "SerA{" +
            "a=" + a +
            ", b=" + b +
            ", c=" + SerA.c +
            ", d=" + d +
            '}';
  }
}
    
private static class B implements Serializable{
  private int b;

  @Override
  public String toString() {
    return "B{" +
            "b=" + b +
            '}';
  }
}

输出

SerA{a=1, b=B{b=2}, c=9, d=0}

由输出可以看出，java序列化会屏蔽transient字段和静态字段，最外层类需要实现Serializable接口，且字段类也需要实现Serializable接口。

要实现自己的序列化逻辑，只需要在被序列化类中添加readObject和writeObject方法

private void writeObject(java.io.ObjectOutputStream out){//...}
private void readObject(java.io.ObjectInputStream in){//...}

ObjectOutputStream和ObjectInputStream会调用这两个方法

//序列化
//slotDesc是ObjectStreamClass类型
if (slotDesc.hasWriteObjectMethod()) {
    //...
    //如果该要序列化的class存在writeObject方法，则调用
    slotDesc.invokeWriteObject(obj, this);
    //...
}

//反序列化
//从流中读取class信息
ObjectStreamClass desc = readClassDesc(false);
//...
//slotDesc是ObjectStreamClass类型
if (slotDesc.hasReadObjectMethod()) {
    //...
    //如果该要序列化的class存在readObject方法，则调用
    slotDesc.invokeReadObject(obj, this);
    //...
}