標記 ktr span ots 引用值 做的 一份 jdk etc

1．淺復制與深復制概念

⑴淺復制（淺克隆）
多個變量指向一個對象
被復制對象的所有變量都含有與原來的對象相同的值，而所有的對其他對象的引用仍然指向原來的對象。換言之，淺復制僅僅復制所考慮的對象，而不復制它所引用的對象。

⑵深復制（深克隆）
每個變量指向一個對象，同時對象內包含對象，能復制內部對象
被復制對象的所有變量都含有與原來的對象相同的值，除去那些引用其他對象的變量。那些引用其他對象的變量將指向被復制過的新對象，而不再是原有的那些被引用的對象。換言之，深復制把要復制的對象所引用的對象都復制了一遍。

2．Java的clone()方法

⑴clone方法將對象復制了一份並返回給調用者。一般而言，clone（）方法滿足：
①對任何的對象x，都有x.clone() !=x//克隆對象與原對象不是同一個對象
②對任何的對象x，都有x.clone().getClass()= =x.getClass()//克隆對象與原對象的類型一樣
③如果對象x的equals()方法定義恰當，那麽x.clone().equals(x)應該成立。

⑵Java中對象的克隆

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

12345678910111213141516171819202122232425262728293031323334

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()識別出你要復制的是哪一個對象。 } 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; //修改學生2後，不影響學生1的值。 System.out.println("name="+s1.name+","+"age="+s1.age); System.out.println("name="+s2.name+","+"age="+s2.age); }}

說明：
①為什麽我們在派生類中覆蓋Object的clone()方法時，一定要調用super.clone()呢？在運行時刻，Object中的clone()識別出你要復制的是哪一個對象，然後為此對象分配空間，並進行對象的復制，將原始對象的內容一一復制到新對象的存儲空間中。

②繼承自java.lang.Object類的clone()方法是淺復制，不能復制對象內部的對象。以下代碼可以證明之。

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647

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;// 學生1和學生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); //輸出結果學生1和2的教授成為lisi,age為30。 } }

那應該如何實現深層次的克隆，即修改s2的教授不會影響s1的教授？代碼改進如下。
改進使學生1的Professor不改變（深層次的克隆）

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061

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()); } //對引用的對象也進行復制 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; //學生1的教授不 改變。 System.out.println("name="+s1.p.name+","+"age="+s1.p.age); System.out.println("name="+s2.p.name+","+"age="+s2.p.age); } }

3．利用串行化來做深復制（主要是為了避免重寫比較復雜對象的深復制的clone（）方法，也可以程序實現斷點續傳等等功能）

把對象寫到流裏的過程是串行化（Serilization）過程，但是在Java程序師圈子裏又非常形象地稱為“冷凍”或者“腌鹹菜（picking）”過程；而把對象從流中讀出來的並行化（Deserialization）過程則叫做 “解凍”或者“回鮮(depicking)”過程。
應當指出的是，寫在流裏的是對象的一個拷貝，而原對象仍然存在於JVM裏面，因此“腌成鹹菜”的只是對象的一個拷貝，Java鹹菜還可以回鮮。
在Java語言裏深復制一個對象，常常可以先使對象實現Serializable接口，然後把對象（實際上只是對象的一個拷貝）寫到一個流裏（腌成鹹菜），再從流裏讀出來（把鹹菜回鮮），便可以重建對象。
如下為深復制源代碼。

1234567891011

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()); }

這樣做的前提是對象以及對象內部所有引用到的對象都是可串行化的，否則，就需要仔細考察那些不可串行化的對象或屬性可否設成transient，從而將之排除在復制過程之外。上例代碼改進如下。

123456789101112131415161718192021222324252627282930313233343536

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;//學生1和學生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; //學生1的老師不改變 System.out.println("name="+s1.t.name+","+"age="+s1.t.age); }}

接口Cloneable與方法clone

標記接口Cloneable與類Object中的方法clone()進行了關聯。 如果不繼承Cloneable接口，當調用clone()時會拋出CloneNotSupportedException異常 Java的所有類都默認繼承java.lang.Object類，在java.lang.Object類中有一個方法clone()。 JDK API的說明文檔解釋這個方法將返回Object對象的一個拷貝。 要說明的有兩點： 一是拷貝對象返回的是一個新對象，而不是一個引用。 二是拷貝對象與用 new操作符返回的新對象的區別就是這個拷貝已經包含了一些原來對象的信息，而不是對象的初始信息。 示例： class CloneClass implements Cloneable{ 　public int aInt; 　public Object clone(){ 　　CloneClass o = null; 　　try{ 　　　o = (CloneClass)super.clone(); 　　}catch(CloneNotSupportedException e){ 　　　e.printStackTrace(); 　　} 　　return o; 　} ｝ 有三個值得註意的地方： 一是實現clone功能的CloneClass類實現了Cloneable接口。 二是Cloneable接口屬於java.lang 包，java.lang包已經被缺省的導入類中，所以不需要寫成java.lang.Cloneable。 三是重載了clone()方法。最後在clone()方法中調用了super.clone()，這也意味著無論clone類的繼承結構是什麽樣的，super.clone()直接或間接調用了java.lang.Object類的clone()方法。 那麽clone類為什麽還要實現 Cloneable接口呢？ Cloneable接口是不包含任何方法的！其實這個接口僅僅是一個標誌，而且這個標誌也僅僅是針對 Object類中clone()方法的， 如果clone類沒有實現Cloneable接口，並調用了Object的clone()方法（也就是調用了 super.Clone()方法），那麽Object的clone()方法就會拋出CloneNotSupportedException異常。

/////////////////////////////////類中數據成員包括：基本類型、引用（引用：變量、常量）在深復制中，String是常量，不需進行復制。

JAVA淺復制與深復制