package com.clone;

import java.io.Serializable;

/**
 * Description:
 * 實現了Cloneable接口，并重寫Object類的clone方法。
 * 
 * @author lee
 * */
public class CloneDemo1 implements Cloneable,Serializable{

  //該克隆類封裝的信息
  public int id;
  public String name;
  public Address address;

  /**
   * Desciption:
   * 默認構造器
   * 
   * */
  public CloneDemo1(){}

  /**
   * Description:
   * 初始化id，name的構造器
   * 
   * @param id id
   * @param name 名字
   * @param address 地址
   * */
  public CloneDemo1(int id, String name, Address address){
    this.id=id;
    this.name=name;
    this.address = address;
  }

  /**
   * Descriptin:
   * 重寫Object類的clone方法。
   * if the object's class does not support the Cloneable interface.
   * Subclasses that override the clone method can also throw this exception 
   * to indicate that an instance cannot be cloned.
   * 
   * @throws CloneNotSupportedException 
   * */
  @Override
  public Object clone() throws CloneNotSupportedException{
    return super.clone();
  }

  /**
   * Description:
   * 重寫toString方法
   * 
   * @return "id="+id+", name="+name
   * */
  @Override
  public String toString(){
    return "id="+id+", name="+name+", address:"+address.getAddress();
  }

  /**
   * Description:
   * 主方法
   * 
   * */
  public static void main(String[] args) throws CloneNotSupportedException{

    CloneDemo1 c1 = new CloneDemo1(1,"c1",new Address("北京"));
    //c2 復制了c1的地址，并沒有復制整個c1對象
    CloneDemo1 c2 = c1;
    //c3 對象的淺克隆，復制了整個對象
    CloneDemo1 c3 = (CloneDemo1)c1.clone();

    //當對象c1改變其name或者id的時候，c2也會自動改變。
    //因為c2只是復制了c1的地址，并非復制了c1的整個對象。
    //相應的c3則不會隨著c1改變而改變，意味著c3將c1整個對象克隆一份出來。

    //當是，對象的淺克隆不會克隆被克隆對象當中的引用對象。
    //因此c1改變其中的Address的引用對象時，c2，c3也會跟著改變。
    c1.setName("cc");
    c1.address.setAddress("上海");
    System.out.println(c1+"\n"+c2+"\n"+c3);



  }

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

}

/**
 * Description:
 * 一個封裝著地址的類
 * 
 * @author lee
 * */
class Address implements Serializable{
  public String address;

  /**
   * Description:
   * 默認構造器
   * 
   * */
  public Address(){}

  /**
   * Description:
   * 初試化address
   * 
   * @param address 地址
   * */
  public Address(String address){
    this.address = address;
  }

  //address的set和get方法
  public String getAddress() {
    return address;
  }

  public void setAddress(String address) {
    this.address = address;
  }
}

package com.clone;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * Description:
 * 實現對象的深克隆
 * 
 * @author lee
 * */
public class CloneDemo2 {

  /**
   * Description:
   * 將對象輸出到一個文件當中。
   * 
   * @param c 需要被寫到文件當中的對象。
   * */
  public static void writeObject(CloneDemo1 c){

    ObjectOutputStream out = null;
    try{

      //將對象輸出在一個object.txt文件當中
      out = new ObjectOutputStream(new FileOutputStream("./object.txt"));
      out.writeObject(c);

    }catch(IOException e){
      System.out.println("寫入對象的時候發生了錯誤。");
      e.printStackTrace();
    }finally{

      //關閉資源
      try{
        out.close();
      }catch(IOException e){
        e.printStackTrace();
      }
    }


  }

  /**
   * Description：
   * 從文件中讀取出一個對象來，并返回。
   * 
   * @return c 返回一個對象。
   * */
  public static CloneDemo1 readObject(){

    CloneDemo1 c = null;
    ObjectInputStream input = null;
    try{
      //從object.txt文件中讀取一個對象出來
      input = new ObjectInputStream(new FileInputStream("./object.txt"));
      c = (CloneDemo1)input.readObject();

    }catch(IOException | ClassNotFoundException e){
      e.printStackTrace();
      System.out.println("讀取對象的時候發生了錯誤。");
    }finally{
      //關閉資源
      try{
        input.close();
      }catch(IOException e){
        e.printStackTrace();
      }
    }
    return c;
  }
  /**
   * Description：
   * 主方法
   * 
   * @throws CloneNotSupportedException 
   * */
  public static void main(String[] args) throws CloneNotSupportedException {
    CloneDemo1 c1 = new CloneDemo1(1,"c1",new Address("北京"));
    //c2 對象的淺克隆
    CloneDemo1 c2 = (CloneDemo1)c1.clone();
    //c3對象的深克隆
    writeObject(c1);
    CloneDemo1 c3 = readObject();

    //因為對象的深克隆同時也克隆了被克隆對象維護的另外一個對象
    //所以，當c1改變其當中的維護的另外一個對象的時候，c3不會隨之改變。
    //而c2位淺克隆，其維護的另外一個對象只是復制了c1維護的對象的地址，因此會隨著c1的改變而改變。
    c1.address.setAddress("上海");
    System.out.println(c1+"\n"+c2+"\n"+c3);

  }

}