Java中clone如何使用

這期內容當中小編將會給大家帶來有關Java中clone如何使用，文章內容豐富且以專業的角度為大家分析和敘述，閱讀完這篇文章希望大家可以有所收獲。

 Cloneable接口

首先，Cloneable接口中并沒有方法。它的存在意義一是讓程序員注明當前對象可以clone，二是改變父類Object類中clone方法的行為：如果某個類實現了Cloneable，那么它的父類Object的clone方法可以調用，否則會拋出CloneNotSupportedException。(奇葩吧)

也就是說，如果我們要告訴用戶，這個類是可以clone的，并且在我們的實現中需要調用super.clone，那么我們就必須實現Cloneable。

（然而，即使某個類實現了Cloneable，也不一定保證它就有clone方法，這是這個接口設計的奇葩之處之一，設計者可能是反社會吧） 

我們的clone方法

需要重寫clone方法的情況分為兩類。

　　　　1：需要實現Cloneable接口。

　　　　2：只需要重寫clone方法。

其中，第一種情況比較普遍。第二種可以看作為了討論的完整性對第一種進行的補充。

需要實現Cloneable接口

考慮到clone方法是直接給用戶用的，建議做到以下幾點：

將限制符改為public；

將它的返回類型設置成子類類型（可以這么做是因為java允許covariant return type）；

接住CloneNotSupportedException并不再拋出（既然已經實現了Cloneable接口，就不會拋出這個異常，不然用戶又要在

那里try-catch半天）。

@Override
public PhoneNumber clone() throws ... {
  try {
   return (PhoneNumber) super.clone();
  } catch(CloneNotSupportedException e) {
   throw new AssertionError(); // Can't happen
  }
}

注意，這里給出的是clone方法的大體寫法，包括函數簽名等，先讓你有一個大略的方向。當我們按照以上三條搭好clone方法的框框后，具體如何去實現克隆的過程，下一節會舉例詳述。

注：如果當前類是final的，可以直接使用構造器來構造對象。（如果不是final的，那么可能還會有子類，子類再調用super.clone的時候就只能返回父類類型對象，就不太合適了，所以只有final類適合用構造器）

只需要重寫clone方法

這個類可能是繼承鏈上的一個中間類。此時該clone方法最好模擬Object.clone的行為，即：

限制符為protected；

不實現Cloneable；

拋出CloneNotSupportedException。

不同情景下的clone方法實現

首先，應熟悉Object.clone的行為（因為在我們自己的類中經常會調用super.clone，最終調用Object.clone）：淺拷貝。即：先創建一個新對象，然后將它的所有域初始化為待拷貝對象的域的對應值。

另外，所有數組都會實現Cloneable接口，T[].clone的返回類型也為T[]，行為與Object類似。（這是一個好用的feature，實現淺拷貝時會經常用到）

官方文檔對clone的實現建議是：先調用super.clone創建對象；如果對象的域都是基本類型，則一切搞定；否則，如果對象是可變對象，則要將組成對象的"deep structure"的對象全部復制，然后將復制品的域引用指向這些復制后的對象。 

上一節給出的PhoneNumber的clone屬于前者（對象域為電話號碼、區號等，為基本類型short），所以調用super.clone再加一個cast就可以搞定。

注意這個藍色的deep structure，指明了clone方法實現的精髓。以下舉兩個例子，讀者可細細品味。

案例一：Stack

public class Stack {
 private Object[] elements;
 private int size = 0;
 private static final int DEFAULT_INITIAL_CAPACITY = 16;
 public Stack() {...}
 public void push(Object e) {...}
 public Object pop() {...}
 private void ensureCapacity() {...} //omitted for simplicity
}

如果在Stack的clone方法中，也簡單地返回super.clone，會有一個嚴重的后果，就是在原對象中如果增刪了元素，在復制對象中的size不變，但是實際上元素被增刪了，違反了復制對象的invariant。

解決辦法是將elements數組獨立克隆：

@Override public Stack clone() {
 try {
  Stack result = (Stack) super.clone();
  result.elements = elements.clone();
  return result;
 } catch (CloneNotSupportedException e) {
  throw new AssertionError();
 }
}

兩種方法的區別如下：（渣圖……）

第一種方法對應左圖，由于克隆后的對象的elements指向原對象中的數組，當原對象增刪元素時，克隆后的對象的backing array也跟著自動變化。第二種方法對應右圖，克隆后對象的數組和原對象的數組是互相獨立的，當原對象增刪元素時，克隆后的對象可以不受影響，因為它還保持原有的那些引用。雖然兩種都是淺拷貝，但只有第二種符合不變性。而且第二種是容器類的一種常用做法，如ArrayList的copy constructor。

案例二：HashTable

在Stack的基礎上再復雜一點，我們研究一個HashTable:

public class HashTable implements Cloneable {
  private Entry[] buckets = ...;
  private static class Entry {
   final Object key;
   Object value;
   Entry next;
   Entry(Object key, Object value, Entry next) {
     this.key = key;
     this.value = value;
     this.next = next;
   }
  }
  ... // Remainder omitted
}

如果我們照搬Stack的克隆方法，是否會有效呢？

@Override public HashTable clone() {
  try {
   HashTable result = (HashTable) super.clone();
   result.buckets = buckets.clone();
   return result;
  } catch (CloneNotSupportedException e) {
   throw new AssertionError();
  }
}

克隆后的HashTable有自己的array了，看起來好像沒什么問題了。然而，HashTable使用的是Entry對象頭尾相接的鏈表。克隆后Entry元素們還指向同樣的對象，此時如果原table增刪了元素，其實質是它將某些Entry指向了新Entry或指向null；由于克隆后的table與克隆前的table共享一套Entry對象，所以它的內部結構發生了同樣的改變，但它并不知道自己發生了改變，這樣就出現了奇怪的現象，比如說克隆后的table的size明明沒變，卻憑空多出/消失了一些元素。

HashTable original = new HashTable();
original.put(x, y);
HashTable cloned = original.clone();
original.remove(x); //cloned gets removed by one element too, but does not know of it!!
if(cloned.size() > 0){
  doSomething(); //Danger! It's actually empty!!  
}

如圖：

解決方法是將其中value的容器Entry做深拷貝。

public class HashTable implements Cloneable {
  private Entry[] buckets = ...;
  private static class Entry {
   final Object key;
   Object value;
   Entry next;
   Entry(Object key, Object value, Entry next) {
   this.key = key;
   this.value = value;
   this.next = next;
   // Recursively copy the linked list headed by this Entry
   Entry deepCopy() {
     return new Entry(key, value, next == null ? null : next.deepCopy());
   }  
 }
  @Override public HashTable clone() {
   try {
     HashTable result = (HashTable) super.clone();
     result.buckets = new Entry[buckets.length];
     for (int i = 0; i < buckets.length; i++)
      if (buckets[i] != null)
       result.buckets[i] = buckets[i].deepCopy();
     return result;
   } catch (CloneNotSupportedException e) {
     throw new AssertionError();
   }
  }
  ... // Remainder omitted
}

注：value指向的Object仍然沒變，所以這種方法只是在一定程度上做深拷貝。由于HashTable直接操作的是Entry，將Entry這一層深拷貝即可。

由于上述deepCopy()方法容易引起stack overflow，作者建議使用iteration代替recursion.

//Iteratively copy the linked list headed by this Entry
Entry deepCopy() {
  Entry result = new Entry(key, value, next);
  for (Entry p = result; p.next != null; p = p.next)
   p.next = new Entry(p.next.key, p.next.value, p.next.next);
  return result;
}

其他碎碎念

（非final類的）clone方法不應調用克隆后對象的nonfinal方法。若該類的子類重寫了這個nonfinal方法，該方法有可能在子類創建完畢之前去調用它的一些方法/數據，可能會引起數據損壞。

如果類中有一個指向可變對象的final域，則以上的clone實現機制無法work，因為對象創建好以后無法再給final域assign一個值。

不可變類不應該支持clone，因為clone后的對象跟原對象沒有區別。
其實一種比較好的方法是copy constructor或copy factory。它們沒有Cloneable的那些奇葩性，不拋異常，而且可以搞定final域。

public Yum(Yum yum); //copy constructor
public static Yum newInstance(Yum yum); //copy factory

一個更好的好處是，interface-based copy constructor或copy factory (稱為conversion constructors / conversion factories)可以允許用戶選擇與原對象不同類的克隆對象。如

HashSet s = ...;
new TreeSet(s); //將HashSet轉換成TreeSet

上述就是小編為大家分享的Java中clone如何使用了，如果剛好有類似的疑惑，不妨參照上述分析進行理解。如果想知道更多相關知識，歡迎關注億速云行業資訊頻道。