[Java]clone()的使用與注意事項

每個類別都有一個 clone() 的 method，是從 java.lang.Object 繼承而來的
以前沒有用過 clone() 這個功能，最近因為工作的需要才開始用到
也因此發現在之前寫的程式有一些盲點


先來提提要如何使用 clone()
在一般的情狀下直接呼叫 clone() 會出現 CloneNotSupportedException
若希望這個 Class 是可以被 clone 的，則此類別必須 implements java.lang.Cloneable
只要 implements Cloneable，呼叫 clone() 就可以成功了 (註)
clone() 回傳的物件，所有的屬性值會跟原始物件完全相同

不過請注意到上面的那句話，所有的屬性值會跟原始物件「完全相同」
在 Object.clone() API 裡也有說明到預設的 clone 動作是淺層複製
也就是說，若某個屬性值是類別型態，並不會對此屬性值再去呼叫它的 clone()
所以原始物件與複製出來的物件，其同一個屬性會參照到同一個物件實體

例如

package test.lang;

import java.util.ArrayList;

public class TestClone1 implements Cloneable {
 private int i;
 private ArrayList list;
 
 @Override
 public String toString() {
  return "i="+i+",list="+list;
 }

 public static void main(String[] args) {
  TestClone1 o1 = new TestClone1();
  o1.i = 3;
  o1.list = new ArrayList();
  o1.list.add("element 1");
  TestClone1 o2 = null;
  try {
   o2 = (TestClone1) o1.clone();
  } catch (CloneNotSupportedException e) {
   e.printStackTrace();
  }
  System.out.println("o1:"+o1);
  System.out.println("o2:"+o2);
  
  o1.i = 5;
  o1.list.add("element 2");
  System.out.println("o1:"+o1);
  System.out.println("o2:"+o2);
  
  System.out.println("o1.list==o2.list?"+(o1.list==o2.list));
 }
}

這個例子的執行結果如下
o1:i=3,list=[element 1]
o2:i=3,list=[element 1]
o1:i=5,list=[element 1, element 2]
o2:i=3,list=[element 1, element 2]
o1.list==o2.list?true

我們可以發現，當修改了 o1.i 的值時，o2.i 的值不會跟著變
但當在 o1.list 中加入一個項目後，o2.list 也同時增加了一個項目
最後我們直接用 == 來比對 o1.list 與 o2.list，得到的結果是 true，表示它們真的是同一個實體
若我們查一下 ArrayList 的 API 可以看到它是有 implements Cloneable 的
而這裡仍然是同一個實體，就表示就算屬性的型態有 implements Cloneable 也不會去呼叫它的 clone()

上面的(註)，我在這裡來說：
在 Cloneable API 中有提到，Object.clone() 是 protected 的
習慣上，實作 Cloneable 的 Class 應該 override clone() 改成 public
並且改寫成適合該 Class 的 clone 方式

所以上例我們應該改寫 clone() ，並自己去對成員做 clone 的動作，例如

package test.lang;

import java.util.ArrayList;

public class TestClone1 implements Cloneable {
 private int i;
 private ArrayList list;
 
 @Override
 public String toString() {
  return "i="+i+",list="+list;
 }
 
 @Override
 public Object clone() throws CloneNotSupportedException {
  TestClone1 o = (TestClone1) super.clone();
  o.list =(ArrayList) this.list.clone();
  return o;
 }

 public static void main(String[] args) {
  TestClone1 o1 = new TestClone1();
  o1.i = 3;
  o1.list = new ArrayList();
  o1.list.add("element 1");
  TestClone1 o2 = null;
  try {
   o2 = (TestClone1) o1.clone();
  } catch (CloneNotSupportedException e) {
   e.printStackTrace();
  }
  System.out.println("o1:"+o1);
  System.out.println("o2:"+o2);
  
  o1.i = 5;
  o1.list.add("element 2");
  System.out.println("o1:"+o1);
  System.out.println("o2:"+o2);
  
  System.out.println("o1.list==o2.list?"+(o1.list==o2.list));
 }
}

如此執行結果就會是
o1:i=3,list=[element 1]
o2:i=3,list=[element 1]
o1:i=5,list=[element 1, element 2]
o2:i=3,list=[element 1]
o1.list==o2.list?false
true

這樣就沒問題了

接下來就要來談談我上面所說的盲點了

在之前，我在寫 Inner class (或稱 Nested class) 時，若 Inner class 需要用到主類的成員，我大概都會這樣寫

package test.lang;

public class TestClone2 implements Cloneable {
 private int i;
 private InnerClass ic;
 public TestClone2() {
  this.i = 3;
  this.ic = new InnerClass();
 }
 
 private class InnerClass{
  private int j;
  public InnerClass() {
   this.j = 8;
  }
  void print(){
   System.out.println("i="+TestClone2.this.i+",j="+this.j);
  }
 }
 public static void main(String[] args) {
  TestClone2 o1 = new TestClone2();
  o1.ic.print();
  TestClone2 o2 = null;
  try {
   o2 = (TestClone2) o1.clone();
  } catch (CloneNotSupportedException e) {
   e.printStackTrace();
  }
  o2.i = 5;
  o2.ic.j = 9;
  o2.ic.print();
 }
}

重點就在於 TestClone2.this.i ，也就是

主類名.this.成員

上面我們雖然明白了 o1.ic 與 o2.ic 會是同一個實體
但是在 InnerClass 中所寫的 TestClone2.this 到底是代表什麼

上例實際執行的結果是
i=3,j=8
i=3,j=9

所以在 InnerClass 中所寫的 TestClone2.this 代表的是 o1
也就是呼叫 InnerClass 的 Constructor 時的那個主類的實體
事實上，下面這一行
this.ic = new InnerClass();
是代表
this.ic = this.new InnerClass();

所以有趣的來了，我們試著改寫一下 clone 如下

package test.lang;

public class TestClone2 implements Cloneable {
 private int i;
 private InnerClass ic;
 public TestClone2() {
  this.i = 3;
  this.ic = new InnerClass();
 }
 
 @Override
 public Object clone() throws CloneNotSupportedException {
  TestClone2 o = (TestClone2) super.clone();
  o.ic = (InnerClass) this.ic.clone();
  return o;
 }

 private class InnerClass implements Cloneable{
  private int j;
  public InnerClass() {
   this.j = 8;
  }
  void print(){
   System.out.println("i="+TestClone2.this.i+",j="+this.j);
  }
  
  @Override
  public Object clone() throws CloneNotSupportedException {
   return super.clone();
  }
 }
 public static void main(String[] args) {
  TestClone2 o1 = new TestClone2();
  o1.ic.print();
  TestClone2 o2 = null;
  try {
   o2 = (TestClone2) o1.clone();
  } catch (CloneNotSupportedException e) {
   e.printStackTrace();
  }
  o2.i = 5;
  o2.ic.j = 9;
  o2.ic.print();
 }
}

再執行看看
結果卻是
i=3,j=8
i=3,j=9

這是怎麼一回事？

我們試著在 Constructor 上加個 log

...(略)...
 public TestClone2() {
  System.out.println("TestClone2 constructor");
  this.i = 3;
  this.ic = new InnerClass();
 }
...(略)...
  public InnerClass() {
   System.out.println("InnerClass constructor");
   this.j = 8;
  }
...(略)...

再執行看看
結果會是
TestClone2 constructor
InnerClass constructor
i=3,j=8
i=3,j=9

所以我們可以看出，clone() 的動作並不會再去呼叫 Constructor
這樣的情況下就算改寫主類的 clone 去呼叫 InnerClass 的 clone() 也是沒有用的
改善的方式，就是不要直接呼叫 InnerClass 的 clone()
而是要自己處理 clone 的動作

例如

package test.lang;

public class TestClone2 implements Cloneable {
 private int i;
 private InnerClass ic;
 public TestClone2() {
  System.out.println("TestClone2 constructor");
  this.i = 3;
  this.ic = new InnerClass();
 }
 
 @Override
 public Object clone() throws CloneNotSupportedException {
  TestClone2 o = (TestClone2) super.clone();
  //下面自己處理 InnerClass 的 clone 動作
  o.ic = o.new InnerClass(); // new 前面的 o. 是不可少的
  o.ic.j = this.ic.j;
  return o;
 }

 private class InnerClass{
  private int j;
  public InnerClass() {
   System.out.println("InnerClass constructor");
   this.j = 8;
  }
  void print(){
   System.out.println("i="+TestClone2.this.i+",j="+this.j);
  }
 }
 public static void main(String[] args) {
  TestClone2 o1 = new TestClone2();
  o1.ic.print();
  TestClone2 o2 = null;
  try {
   o2 = (TestClone2) o1.clone();
  } catch (CloneNotSupportedException e) {
   e.printStackTrace();
  }
  o2.i = 5;
  o2.ic.j = 9;
  o2.ic.print();
 }
}

這樣執行結果就會是
TestClone2 constructor
InnerClass constructor
i=3,j=8
InnerClass constructor
i=5,j=9

另一種方法則是 Inner class 就乾脆改成 static
若在 Inner class 中想使用主類的成員，就要傳參數

例如

package test.lang;

public class TestClone3 implements Cloneable {
 private int i;
 private InnerClass ic;
 public TestClone3() {
  this.i = 3;
  this.ic = new InnerClass();
 }
 
 @Override
 public Object clone() throws CloneNotSupportedException {
  TestClone3 o = (TestClone3) super.clone();
  o.ic = (InnerClass) this.ic.clone();
  return o;
 }

 private static class InnerClass implements Cloneable{
  private int j;
  public InnerClass() {
   this.j = 8;
  }
  void print(TestClone3 o){
   System.out.println("i="+o.i+",j="+this.j);
  }
  @Override
  public Object clone() throws CloneNotSupportedException {
   return super.clone();
  }
 }
 public static void main(String[] args) {
  TestClone3 o1 = new TestClone3();
  o1.ic.print(o1);
  TestClone3 o2 = null;
  try {
   o2 = (TestClone3) o1.clone();
  } catch (CloneNotSupportedException e) {
   e.printStackTrace();
  }
  o2.i = 5;
  o2.ic.j = 9;
  o2.ic.print(o2);
 }
}