被復(fù)制對象的所有變量都含有與原來的對象相同的值，除去那些引用其他對象的變量。那些引用其他對象的變量將指向被復(fù)制過的新對象，而不再是原有的那些被引用的對象。換言之，深復(fù)制把要復(fù)制的對象所引用的對象都復(fù)制了一遍。

2．Java的clone()方法

⑴clone方法將對象復(fù)制了一份并返回給調(diào)用者。一般而言，clone（）方法滿足：

①對任何的對象x，都有x.clone() !=x//克隆對象與原對象不是同一個(gè)對象
②對任何的對象x，都有x.clone().getClass()= =x.getClass()//克隆對象與原對象的類型一樣
③如果對象x的equals()方法定義恰當(dāng)，那么x.clone().equals(x)應(yīng)該成立。

⑵Java中對象的克隆

①為了獲取對象的一份拷貝，我們可以利用Object類的clone()方法。
②在派生類中覆蓋基類的clone()方法，并聲明為public。
③在派生類的clone()方法中，調(diào)用super.clone()。
④在派生類中實(shí)現(xiàn)Cloneable接口。

請看如下代碼：

public class Student implements Cloneable 
{ 
  String name; 
int age; 
  Student(String name,int age) 
  { 
  this.name=name; 
  this.age=age; 
  } 
public Object clone() 
  { 
   Object o=null; 
  try 
   { 
   o=(Student)super.clone();//Object 中的clone()識(shí)別出你要復(fù)制的是哪一個(gè)對象。 
   } 
  catch(CloneNotSupportedException e) 
   { 
    System.out.println(e.toString()); 
   } 
  return o; 
  }  
 
public static void main(String[] args) 
  { 
  Student s1=new Student("zhangsan",18); 
  Student s2=(Student)s1.clone(); 
  s2.name="lisi"; 
  s2.age=20; 
  //修改學(xué)生2后，不影響學(xué)生1的值。 
  System.out.println("name="+s1.name+","+"age="+s1.age); 
  System.out.println("name="+s2.name+","+"age="+s2.age); 
} 
} 

說明：

①為什么我們在派生類中覆蓋Object的clone()方法時(shí)，一定要調(diào)用super.clone()呢？在運(yùn)行時(shí)刻，Object中的 clone() 識(shí)別出你要復(fù)制的是哪一個(gè)對象，然后為此對象分配空間，并進(jìn)行對象的復(fù)制，將原始對象的內(nèi)容一一復(fù)制到新對象的存儲(chǔ)空間中。

②繼承自java.lang.Object類的clone()方法是淺復(fù)制。以下代碼可以證明之。

class Professor 
{ 
  String name; 
  int age; 
  Professor(String name,int age) 
  { 
  this.name=name; 
  this.age=age; 
  } 
} 
public class Student implements Cloneable 
{ 
  String name;// 常量對象。 
  int age; 
  Professor p;// 學(xué)生1和學(xué)生2的引用值都是一樣的。 
  Student(String name,int age,Professor p) 
  { 
  this.name=name; 
  this.age=age; 
  this.p=p; 
  } 
public Object clone() 
  { 
   Student o=null; 
  try 
   { 
    o=(Student)super.clone(); 
   } 
  catch(CloneNotSupportedException e) 
   { 
    System.out.println(e.toString()); 
   } 
   o.p=(Professor)p.clone(); 
  return o; 
  }  
public static void main(String[] args) 
{ 
  Professor p=new Professor("wangwu",50); 
  Student s1=new Student("zhangsan",18,p); 
  Student s2=(Student)s1.clone(); 
  s2.p.name="lisi"; 
  s2.p.age=30;  
  System.out.println("name="+s1.p.name+","+"age="+s1.p.age); 
  System.out.println("name="+s2.p.name+","+"age="+s2.p.age); 
  //輸出結(jié)果學(xué)生1和2的教授成為lisi,age為30。 
  } 
} 

那應(yīng)該如何實(shí)現(xiàn)深層次的克隆，即修改s2的教授不會(huì)影響s1的教授？代碼改進(jìn)如下。

改進(jìn)使學(xué)生1的Professor不改變（深層次的克?。?/p>

class Professor implements Cloneable 
{ 
  String name; 
  int age; 
  Professor(String name,int age) 
  { 
  this.name=name; 
  this.age=age; 
  } 
public Object clone() 
  { 
   Object o=null; 
  try 
   { 
    o=super.clone(); 
   } 
  catch(CloneNotSupportedException e) 
   { 
    System.out.println(e.toString()); 
   } 
  return o; 
  } 
} 
public class Student implements Cloneable 
{ 
  String name; 
  int age; 
  Professor p; 
  Student(String name,int age,Professor p) 
  { 
  this.name=name; 
  this.age=age; 
  this.p=p; 
  } 
public Object clone() 
  { 
   Student o=null; 
  try 
   { 
    o=(Student)super.clone(); 
   } 
  catch(CloneNotSupportedException e) 
   { 
    System.out.println(e.toString()); 
   } 
   //對引用的對象也進(jìn)行復(fù)制 
   o.p=(Professor)p.clone(); 
  return o; 
  }  
public static void main(String[] args) 
  { 
  Professor p=new Professor("wangwu",50); 
  Student s1=new Student("zhangsan",18,p); 
  Student s2=(Student)s1.clone(); 
  s2.p.name="lisi"; 
  s2.p.age=30; 
  //學(xué)生1的教授不 改變。 
  System.out.println("name="+s1.p.name+","+"age="+s1.p.age); 
  System.out.println("name="+s2.p.name+","+"age="+s2.p.age); 
} 
} 

3．利用串行化來做深復(fù)制（主要是為了避免重寫比較復(fù)雜對象的深復(fù)制的clone（）方法，也可以程序?qū)崿F(xiàn)斷點(diǎn)續(xù)傳等等功能）

把對象寫到流里的過程是串行化（Serilization）過程，但是在Java程序師圈子里又非常形象地稱為“冷凍”或者“腌咸菜 （picking）” 過程；而把對象從流中讀出來的并行化（Deserialization）過程則叫做 “解凍”或者“回鮮(depicking)”過程。

應(yīng)當(dāng)指出的是，寫在流里的是對象的一個(gè)拷貝，而原對象仍然存在于JVM里面，因此“腌成咸菜”的只是對象的一個(gè)拷貝，Java咸菜還可以回鮮。

在Java語言里深復(fù)制一個(gè)對象，常?？梢韵仁箤ο髮?shí)現(xiàn)Serializable接口，然后把對象（實(shí)際上只是對象的一個(gè)拷貝）寫到一個(gè)流里（腌成咸菜），再從流里讀出來（把咸菜回鮮），便可以重建對象。

如下為深復(fù)制源代碼。

public Object deepClone() 
{ 
//將對象寫到流里 
ByteArrayOutoutStream bo=new ByteArrayOutputStream(); 
ObjectOutputStream oo=new ObjectOutputStream(bo); 
oo.writeObject(this); 
//從流里讀出來 
ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray()); 
ObjectInputStream oi=new ObjectInputStream(bi); 
return(oi.readObject()); 
} 

這樣做的前提是對象以及對象內(nèi)部所有引用到的對象都是可串行化的，否則，就需要仔細(xì)考察那些不可串行化的對象或?qū)傩钥煞裨O(shè)成transient，從而將之排除在復(fù)制過程之外。上例代碼改進(jìn)如下。

class Teacher implements Serializable{ 
  String name; 
  int age; 
  public void Teacher(String name,int age){ 
  this.name=name; 
  this.age=age; 
  } 
} 
public class Student implements Serializable{ 
String name;//常量對象 
int age; 
Teacher t;//學(xué)生1和學(xué)生2的引用值都是一樣的。 
public void Student(String name,int age,Teacher t){ 
  this.name=name; 
  this.age=age; 
  this.p=p; 
} 
public Object deepClone() throws IOException, 
    OptionalDataException,ClassNotFoundException{//將對象寫到流里 
  ByteArrayOutoutStream bo=new ByteArrayOutputStream(); 
  ObjectOutputStream oo=new ObjectOutputStream(bo); 
  oo.writeObject(this);//從流里讀出來 
  ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray()); 
  ObjectInputStream oi=new ObjectInputStream(bi); 
  return(oi.readObject()); 
} 
public static void main(String[] args){ 
  Teacher t=new Teacher("tangliang",30); 
  Student s1=new Student("zhangsan",18,t); 
  Student s2=(Student)s1.deepClone(); 
  s2.t.name="tony"; 
  s2.t.age=40; 
  //學(xué)生1的老師不改變 
  System.out.println("name="+s1.t.name+","+"age="+s1.t.age); 
} 
}