Java的clone()：深復制與淺復制
阿新 • • 發佈：2019-02-17
super nbsp pan return 定義類 pub ESS cep 基本 
Java中要想自定義類的對象可以被復制，自定義類就必須實現Cloneable中的clone()方法，如下：
1 public class Student implements Cloneable {
2
3 private String name;
4
5 private int age;
6
7 private Professor professor;
8
9 public String getName() {
10 return name;
11 }
12
13 public void setName(String name) {
14 this.name = name;
15 }
16
17 public int getAge() {
18 return age;
19 }
20
21 public void setAge(int age) {
22 this.age = age;
23 }
24
25 public Professor getProfessor() {
26 return professor;
27 }
28
29 public void setProfessor(Professor professor) {
30 this.professor = professor;
31 }
32
33 @Override
34 public String toString() {
35 return "Student [name=" + name + ", age=" + age + ", professor="
36 + professor + "]";
37 }
38
39 public Object clone() throws CloneNotSupportedException{
40 return super.clone();
41 }
42
43 }
其中，Professor類同樣為自定義類：
public class Professor {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Professor [name=" + name + ", age=" + age + "]";
}
}
然而，當自定義類的字段的類型不是基本數據類型時，上面實現了clone()方法會導致問題，不信看下面的代碼：
【程序實例1】
1 public class ShadowCopy {
2
3 public static void main(String[] args) {
4 Professor p1 = new Professor();
5 p1.setName("Professor Zhang");
6 p1.setAge(30);
7
8 Student s1 = new Student();
9 s1.setName("xiao ming");
10 s1.setAge(18);
11 s1.setProfessor(p1);
12
13 System.out.println(s1);
14
15 try {
16 Student s2 = (Student) s1.clone();
17 Professor p2 = s2.getProfessor();
18 p2.setName("Professor Li");
19 p2.setAge(45);
20 s2.setProfessor(p2);
21 System.out.println("復制後的：s1 = " + s1);
22 System.out.println("復制後的：s2 = " + s2);
23 } catch (CloneNotSupportedException e) {
24 e.printStackTrace();
25 }
26
27 }
28
29 }
【運行結果1】
1 Student [name=xiao ming, age=18, professor=Professor [name=Professor Zhang, age=30]] 2 復制後的：s1 = Student [name=xiao ming, age=18, professor=Professor [name=Professor Li, age=45]] 3 復制後的：s2 = Student [name=xiao ming, age=18, professor=Professor [name=Professor Li, age=45]]
【結果分析】
學生s1的導師為30歲的Professor Zhang，恰好學生s2與學生s1同名同歲，但是s2的導師為45歲的Professor Li，於是我們順理成章地復制復制s1並復制給s2，再修改下s2的導師的信息。可是，問題出現了，當我們修改了s2的導師後，s2的信息是對了，但是s1的導師信息也跟著修改了，這可不是我們期望的。
【問題分析】
程序實例1中的問題出在哪兒呢？我們已經對Student類實現了clone()方法，怎麽還是出問題了呢？我們在看下面的代碼：
【程序實例2】
1 public class ShadowCopy {
2
3 public static void main(String[] args) {
4 Professor p1 = new Professor();
5 p1.setName("Professor Zhang");
6 p1.setAge(30);
7
8 Student s1 = new Student();
9 s1.setName("xiao ming");
10 s1.setAge(18);
11 s1.setProfessor(p1);
12
13 System.out.println(s1);
14
15 try {
16 Student s2 = (Student) s1.clone();
17 s2.setName("xiao hong");
18 s2.setAge(17);
19 Professor p2 = s2.getProfessor();
20 p2.setName("Professor Li");
21 p2.setAge(45);
22 s2.setProfessor(p2);
23 System.out.println("復制後的：s1 = " + s1);
24 System.out.println("復制後的：s2 = " + s2);
25 } catch (CloneNotSupportedException e) {
26 e.printStackTrace();
27 }
28
29 }
30
31 }
【運行結果】
1 Student [name=xiao ming, age=18, professor=Professor [name=Professor Zhang, age=30]] 2 復制後的：s1 = Student [name=xiao ming, age=18, professor=Professor [name=Professor Li, age=45]] 3 復制後的：s2 = Student [name=xiao hong, age=17, professor=Professor [name=Professor Li, age=45]]
【結果分析】
這次，我們在clone後，又修改了s2的name和age，從結果可以看出，s1的name和age並沒有因為s2的修改而改變。
結合程序實例1和程序實例2，我們發現Student的字段如果不是一個引用時，修改clone()得到對象的該字段(name, age)時並不會影響原來的對象，但是當字段為一個引用時，修改clone()得到對象的該字段(professor)時並會影響原來的對象。上面實現的clone()方法為淺復制（shadow copy）。
如果想要clone()得到的新對象的修改不會影響被復制的對象的字段時，我們就需要實現深復制（deep copy），代碼修改如下：
1 public class Professor implements Cloneable {
2
3 private String name;
4
5 private int age;
6
7 public String getName() {
8 return name;
9 }
10
11 public void setName(String name) {
12 this.name = name;
13 }
14
15 public int getAge() {
16 return age;
17 }
18
19 public void setAge(int age) {
20 this.age = age;
21 }
22
23 @Override
24 public String toString() {
25 return "Professor [name=" + name + ", age=" + age + "]";
26 }
27
28 public Object clone() throws CloneNotSupportedException{
29 return super.clone();
30 }
31
32 }
public class Student implements Cloneable {
private String name;
private int age;
private Professor professor;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Professor getProfessor() {
return professor;
}
public void setProfessor(Professor professor) {
this.professor = professor;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", professor="
+ professor + "]";
}
public Object clone() throws CloneNotSupportedException{
Student newStudent = (Student) super.clone();
newStudent.professor = (Professor) professor.clone();
return newStudent;
}
}
再次運行【程序實例2】得到的結果為：
1 Student [name=xiao ming, age=18, professor=Professor [name=Professor Zhang, age=30]] 2 復制後的：s1 = Student [name=xiao ming, age=18, professor=Professor [name=Professor Zhang, age=30]] 3 復制後的：s2 = Student [name=xiao hong, age=17, professor=Professor [name=Professor Li, age=45]]
可以看到：修改clone()得到的s2的任何字段都不會影響s1的字段，這也就是深復制的作用。
Java的clone()：深復制與淺復制