假如說你想復制一個簡單變量。很簡單：

 

int apples = 5;    
int pears = apples; 

不僅僅是int類型，其它七種原始數據類型(boolean,char,byte,short,float,double.long)同樣適用于該類情況。

但是如果你復制的是一個對象，情況就有些復雜了。

假設說我是一個beginner，我會這樣寫：

 

class Student {    
   private int number;     
   public int getNumber() {  
       return number;    
   }  
 
   public void setNumber(int number) {    
       this.number = number;    
   }   
}    
public class Test {    
   public static void main(String args[]) {   
       Student stu1 = new Student();    
       stu1.setNumber(12345);    
       Student stu2 = stu1;             
 
       System.out.println("學生1:" + stu1.getNumber());    
       System.out.println("學生2:" + stu2.getNumber());   
   }    
} 

結果：

 

學生1:12345   
學生2:12345 

這里我們自定義了一個學生類，該類只有一個number字段。

我們新建了一個學生實例，然后將該值賦值給stu2實例。(Student stu2 = stu1;)

再看看打印結果，作為一個新手，拍了拍胸腹，對象復制不過如此！

難道真的是這樣嗎？

我們試著改變stu2實例的number字段，再打印結果看看：

 

stu2.setNumber(54321);     
System.out.println("學生1:" + stu1.getNumber());    
System.out.println("學生2:" + stu2.getNumber()); 

結果：

 

學生1:54321    
學生2:54321 

這就怪了，為什么改變學生2的學號，學生1的學號也發生了變化呢？

原因出在(stu2 = stu1) 這一句。該語句的作用是將stu1的引用賦值給stu2，這樣，stu1和stu2指向內存堆中同一個對象。如圖：

那么，怎樣才能達到復制一個對象呢？

是否記得萬類之王Object。它有11個方法，有兩個protected的方法，其中一個為clone方法。

在Java中所有的類都是缺省的繼承自Java語言包中的Object類的，查看它的源碼，你可以把你的JDK目錄下的src.zip復制到其他地方然后解壓，里面就是所有的源碼。發現里面有一個訪問限定符為protected的方法clone()：

 

/*  
Creates and returns a copy of this object. The precise meaning of "copy" may depend on the class of the object.  
The general intent is that, for any object x, the expression:  
1) x.clone() != x will be true  
2) x.clone().getClass() == x.getClass() will be true, but these are not absolute requirements.  
3) x.clone().equals(x) will be true, this is not an absolute requirement.  
*/  
protected native Object clone() throws CloneNotSupportedException; 

仔細一看，它還是一個native方法，大家都知道native方法是非Java語言實現的代碼，供Java程序調用的，因為Java程序是運行在JVM虛擬機上面的，要想訪問到比較底層的與操作系統相關的就沒辦法了，只能由靠近操作系統的語言來實現。

第一次聲明保證克隆對象將有單獨的內存地址分配。

第二次聲明表明，原始和克隆的對象應該具有相同的類類型，但它不是強制性的。

第三聲明表明，原始和克隆的對象應該是平等的equals()方法使用，但它不是強制性的。

因為每個類直接或間接的父類都是Object，因此它們都含有clone()方法，但是因為該方法是protected，所以都不能在類外進行訪問。

要想對一個對象進行復制，就需要對clone方法覆蓋。

為什么要克隆？

大家先思考一個問題，為什么需要克隆對象？直接new一個對象不行嗎？

答案是：克隆的對象可能包含一些已經修改過的屬性，而new出來的對象的屬性都還是初始化時候的值，所以當需要一個新的對象來保存當前對象的“狀態”就靠clone方法了。那么我把這個對象的臨時屬性一個一個的賦值給我新new的對象不也行嘛？可以是可以，但是一來麻煩不說，二來，大家通過上面的源碼都發現了clone是一個native方法，就是快啊，在底層實現的。

提個醒，我們常見的Object a=new Object();Object b;b=a;這種形式的代碼復制的是引用，即對象在內存中的地址，a和b對象仍然指向了同一個對象。

而通過clone方法賦值的對象跟原來的對象時同時獨立存在的。

如何實現克隆

先介紹一下兩種不同的克隆方法，淺克隆(ShallowClone)和深克隆(DeepClone)。

在Java語言中，數據類型分為值類型（基本數據類型）和引用類型，值類型包括int、double、byte、boolean、char等簡單數據類型，引用類型包括類、接口、數組等復雜類型。淺克隆和深克隆的主要區別在于是否支持引用類型的成員變量的復制，下面將對兩者進行詳細介紹。

一般步驟是（淺克隆）：

1. 被復制的類需要實現Clonenable接口（不實現的話在調用clone方法會拋出CloneNotSupportedException異常)， 該接口為標記接口(不含任何方法)

2. 覆蓋clone()方法，訪問修飾符設為public。方法中調用super.clone()方法得到需要的復制對象。（native為本地方法)

下面對上面那個方法進行改造：

 

class Student implements Cloneable{   
   private int number;     
   public int getNumber() {   
       return number;    
   }     
   public void setNumber(int number) {    
       this.number = number;    
   }   
 
   @Override    
   public Object clone() {  
       Student stu = null;    
       try{    
           stu = (Student)super.clone();    
       }catch(CloneNotSupportedException e) {    
           e.printStackTrace();   
       }    
       return stu;    
   }    
}    
public class Test {  
   public static void main(String args[]) {   
       Student stu1 = new Student();   
       stu1.setNumber(12345);    
       Student stu2 = (Student)stu1.clone();             
 
       System.out.println("學生1:" + stu1.getNumber());  
       System.out.println("學生2:" + stu2.getNumber());   
          
       stu2.setNumber(54321);   
 
       System.out.println("學生1:" + stu1.getNumber());    
       System.out.println("學生2:" + stu2.getNumber());   
   }    
} 

結果：

 

學生1:12345  
學生2:12345   
學生1:12345   
學生2:54321 

如果你還不相信這兩個對象不是同一個對象，那么你可以看看這一句：

 

System.out.println(stu1 == stu2); // false 

上面的復制被稱為淺克隆。

還有一種稍微復雜的深度復制：

我們在學生類里再加一個Address類。

 

class Address  {   
   private String add;    
   public String getAdd() {  
       return add;   
   }   
 
   public void setAdd(String add) {    
       this.add = add;   
   }    
}   
 
class Student implements Cloneable{   
   private int number;    
   private Address addr;       
 
   public Address getAddr() {    
       return addr;    
   }   
 
   public void setAddr(Address addr) {    
       this.addr = addr;  
   }   
 
   public int getNumber() {    
       return number;    
   }     
 
   public void setNumber(int number) {    
       this.number = number;   
   }    
 
   @Override    
   public Object clone() {    
       Student stu = null;    
       try{    
           stu = (Student)super.clone();    
       }catch(CloneNotSupportedException e) {   
           e.printStackTrace();    
       }    
       return stu;    
   }    
}    
public class Test {    
   public static void main(String args[]) {    
       Address addr = new Address();    
       addr.setAdd("杭州市");    
       Student stu1 = new Student();   
       stu1.setNumber(123);    
       stu1.setAddr(addr);           
 
       Student stu2 = (Student)stu1.clone(); 
       System.out.println("學生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());   
       System.out.println("學生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());   
   }   
} 

結果：

 

學生1:123,地址:杭州市    
學生2:123,地址:杭州市 

乍一看沒什么問題，真的是這樣嗎？

我們在main方法中試著改變addr實例的地址。

 

addr.setAdd("西湖區");     
System.out.println("學生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());    
System.out.println("學生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd()); 

結果：

 

學生1:123,地址:杭州市    
學生2:123,地址:杭州市  
學生1:123,地址:西湖區   
學生2:123,地址:西湖區 

這就奇怪了，怎么兩個學生的地址都改變了？

原因是淺復制只是復制了addr變量的引用，并沒有真正的開辟另一塊空間，將值復制后再將引用返回給新對象。

所以，為了達到真正的復制對象，而不是純粹引用復制。我們需要將Address類可復制化，并且修改clone方法，完整代碼如下：

 

package abc;    
class Address implements Cloneable {  
   private String add;    
   public String getAdd() {   
       return add;    
   }     
   public void setAdd(String add) {    
       this.add = add;    
   }     
 
   @Override   
   public Object clone() {   
       Address addr = null;    
       try{    
           addr = (Address)super.clone();   
       }catch(CloneNotSupportedException e) {    
           e.printStackTrace();    
       }    
       return addr;    
   }    
}     
 
class Student implements Cloneable{    
   private int number;     
   private Address addr;         
 
   public Address getAddr() {  
       return addr;    
   }   
 
   public void setAddr(Address addr) {    
       this.addr = addr;   
   }   
 
   public int getNumber() {    
       return number;    
   }   
   public void setNumber(int number) {    
       this.number = number;   
   }   
 
   @Override    
   public Object clone() {    
       Student stu = null;    
       try{    
           stu = (Student)super.clone();   //淺復制    
       }catch(CloneNotSupportedException e) {    
           e.printStackTrace();    
       }    
       stu.addr = (Address)addr.clone();   //深度復制    
       return stu;    
   }    
}    
public class Test {   
    public static void main(String args[]) {   
       Address addr = new Address();    
       addr.setAdd("杭州市");   
       Student stu1 = new Student();   
       stu1.setNumber(123);   
       stu1.setAddr(addr);    
       Student stu2 = (Student)stu1.clone();   
 
       System.out.println("學生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
       System.out.println("學生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());   
 
       addr.setAdd("西湖區");    
       System.out.println("學生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
       System.out.println("學生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());    
   }    
} 

結果：

 

學生1:123,地址:杭州市    
學生2:123,地址:杭州市   
學生1:123,地址:西湖區  
學生2:123,地址:杭州市 

這樣結果就符合我們的想法了。 

最后我們可以看看API里其中一個實現了clone方法的類：

 

java.util.Date:  
/**   
* Return a copy of this object.   
*/   
 public Object clone() {    
   Date d = null;    
   try {    
       d = (Date)super.clone();  
       if (cdate != null) {    
           d.cdate = (BaseCalendar.Date) cdate.clone();   
       }    
   } catch (CloneNotSupportedException e) {} // Won't happen    
   return d;   
} 

該類其實也屬于深度復制。

淺克隆和深克隆

1、淺克隆

在淺克隆中，如果原型對象的成員變量是值類型，將復制一份給克隆對象；如果原型對象的成員變量是引用類型，則將引用對象的地址復制一份給克隆對象，也就是說原型對象和克隆對象的成員變量指向相同的內存地址。

簡單來說，在淺克隆中，當對象被復制時只復制它本身和其中包含的值類型的成員變量，而引用類型的成員對象并沒有復制。

在Java語言中，通過覆蓋Object類的clone()方法可以實現淺克隆。

2、深克隆

在深克隆中，無論原型對象的成員變量是值類型還是引用類型，都將復制一份給克隆對象，深克隆將原型對象的所有引用對象也復制一份給克隆對象。

簡單來說，在深克隆中，除了對象本身被復制外，對象所包含的所有成員變量也將復制。

在Java語言中，如果需要實現深克隆，可以通過覆蓋Object類的clone()方法實現，也可以通過序列化(Serialization)等方式來實現。

（如果引用類型里面還包含很多引用類型，或者內層引用類型的類里面又包含引用類型，使用clone方法就會很麻煩。這時我們可以用序列化的方式來實現對象的深克隆。）

序列化就是將對象寫到流的過程，寫到流中的對象是原有對象的一個拷貝，而原對象仍然存在于內存中。通過序列化實現的拷貝不僅可以復制對象本身，而且可以復制其引用的成員對象，因此通過序列化將對象寫到一個流中，再從流里將其讀出來，可以實現深克隆。需要注意的是能夠實現序列化的對象其類必須實現Serializable接口，否則無法實現序列化操作。

擴展

Java語言提供的Cloneable接口和Serializable接口的代碼非常簡單，它們都是空接口，這種空接口也稱為標識接口，標識接口中沒有任何方法的定義，其作用是告訴JRE這些接口的實現類是否具有某個功能，如是否支持克隆、是否支持序列化等。

解決多層克隆問題

如果引用類型里面還包含很多引用類型，或者內層引用類型的類里面又包含引用類型，使用clone方法就會很麻煩。這時我們可以用序列化的方式來實現對象的深克隆。

 

public class Outer implements Serializable{  
 private static final long serialVersionUID = 369285298572941L;  //最好是顯式聲明ID  
 public Inner inner;  
　//Discription:[深度復制方法,需要對象及對象所有的對象屬性都實現序列化]　  
 public Outer myclone() {  
     Outer outer = null;  
     try { // 將該對象序列化成流,因為寫在流里的是對象的一個拷貝，而原對象仍然存在于JVM里面。所以利用這個特性可以實現對象的深拷貝  
         ByteArrayOutputStream baos = new ByteArrayOutputStream();  
         ObjectOutputStream oos = new ObjectOutputStream(baos);  
         oos.writeObject(this);  
　　　　　　// 將流序列化成對象  
         ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());  
         ObjectInputStream ois = new ObjectInputStream(bais);  
         outer = (Outer) ois.readObject();  
     } catch (IOException e) {  
         e.printStackTrace();  
     } catch (ClassNotFoundException e) {  
         e.printStackTrace();  
     }  
     return outer;  
 }  
} 

Inner也必須實現Serializable，否則無法序列化：

 

public class Inner implements Serializable{  
 private static final long serialVersionUID = 872390113109L; //最好是顯式聲明ID  
 public String name = "";  
 public Inner(String name) {  
     this.name = name; 
 } 
 
 @Override  
 public String toString() {  
     return "Inner的name值為：" + name;  
 }  
} 

這樣也能使兩個對象在內存空間內完全獨立存在，互不影響對方的值。

總結

實現對象克隆有兩種方式：

1). 實現Cloneable接口并重寫Object類中的clone()方法；

2). 實現Serializable接口，通過對象的序列化和反序列化實現克隆，可以實現真正的深度克隆。

注意：基于序列化和反序列化實現的克隆不僅僅是深度克隆，更重要的是通過泛型限定，可以檢查出要克隆的對象是否支持序列化，這項檢查是編譯器完成的，不是在運行時拋出異常，這種是方案明顯優于使用Object類的clone方法克隆對象。讓問題在編譯的時候暴露出來總是優于把問題留到運行時。

原文鏈接：www.cnblogs.com/Qian123/p/5710533.html