JAVA深複製(深克隆)與淺複製(淺克隆)

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接口。

請看以下代碼：

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;    
       System.out.println("name="+s1.name+","+"age="+s1.age);//修改學生2後，不影響學生1的值。    
    }   

說明：
①爲何咱們在派生類中覆蓋Object的clone()方法時，必定要調用super.clone()呢？在運行時刻，Object中的clone()識別出你要複製的是哪個對象，而後爲此對象分配空間，並進行對象的複製，將原始對象的內容一一複製到新對象的存儲空間中。 
②繼承自java.lang.Object類的clone()方法是淺複製。如下代碼能夠證實之。

class Professor    
{    
     String name;    
     int age;    
     Professor(String name,int age)    
     {    
        this.name=name;    
        this.age=age;    
     }    
}    
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);//學生1的教授成爲lisi,age爲30。    
}   

那應該如何實現深層次的克隆，即修改s2的教授不會影響s1的教授？代碼改進以下。

改進使學生1的Professor不改變（深層次的克隆）
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;    
     }    
}    
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;    
System.out.println("name="+s1.p.name+","+"age="+s1.p.age);//學生1的教授不 改變。    
}    
3．利用串行化來作深複製
把對象寫到流裏的過程是串行化（Serilization）過程，可是在Java程序師圈子裏又很是形象地稱爲「冷凍」或者「醃鹹菜（picking）」過程；而把對象從流中讀出來的並行化（Deserialization）過程則叫作 「解凍」或者「回鮮(depicking)」過程。

應當指出的是，寫在流裏的是對象的一個拷貝，而原對象仍然存在於JVM裏面，所以「醃成鹹菜」的只是對象的一個拷貝，Java鹹菜還能夠回鮮。
在Java語言裏深複製一個對象，經常能夠先使對象實現Serializable接口，而後把對象（實際上只是對象的一個拷貝）寫到一個流裏（醃成鹹菜），再從流裏讀出來（把鹹菜回鮮），即可以重建對象。
以下爲深複製源代碼。
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，從而將之排除在複製過程以外。上例代碼改進以下。
class Teacher implements Serializable{
String name;
int age;
Teacher(String name,int age){
this.name=name;
this.age=age;
}
}
class Student implements Serializable{
String name;//常量對象
int age;
Teacher t;//學生1和學生2的引用值都是同樣的。
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; System.out.println("name="+s1.t.name+","+"age="+s1.t.age);//學生1的老師不改變 }