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

1. intapples=5;
2. intpears=apples;

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

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

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

1. classStudent{
2. PRivateintnumber;
4. publicintgetNumber(){
5. returnnumber;
6. }
8. publicvoidsetNumber(intnumber){
9. this.number=number;
10. }
12. }
13. publicclassTest{
15. publicstaticvoidmain(Stringargs[]){
17. Studentstu1=newStudent();
18. stu1.setNumber(12345);
19. Studentstu2=stu1;
21. System.out.println("學生1:"+stu1.getNumber());
22. System.out.println("學生2:"+stu2.getNumber());
23. }
24. }

打印結果：

1. 學生1:12345
2. 學生2:12345

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

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

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

難道真的是這樣嗎？

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

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

打印結果:

1. 學生1:54321
2. 學生2:54321

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

原因出在(stu2 = stu1) 這一句。該語句的作用是將stu1的引用賦值給stu2，

這樣，stu1和stu2指向內存堆中同一個對象。如圖：

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

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

該方法的簽名是：

protected native Object clone() throws CloneNotSupportedException;

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

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

一般步驟是（淺復制）：

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

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

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

1. classStudentimplementsCloneable{
2. privateintnumber;
4. publicintgetNumber(){
5. returnnumber;
6. }
8. publicvoidsetNumber(intnumber){
9. this.number=number;
10. }
12. @Override
13. publicObjectclone(){
14. Studentstu=null;
15. try{
16. stu=(Student)super.clone();
17. }catch(CloneNotSupportedExceptione){
18. e.printStackTrace();
19. }
20. returnstu;
21. }
22. }
23. publicclassTest{
25. publicstaticvoidmain(Stringargs[]){
27. Studentstu1=newStudent();
28. stu1.setNumber(12345);
29. Studentstu2=(Student)stu1.clone();
31. System.out.println("學生1:"+stu1.getNumber());
32. System.out.println("學生2:"+stu2.getNumber());
34. stu2.setNumber(54321);
36. System.out.println("學生1:"+stu1.getNumber());
37. System.out.println("學生2:"+stu2.getNumber());
38. }
39. }

打印結果：

1. 學生1:12345
2. 學生2:12345
3. 學生1:12345
4. 學生2:54321

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

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

上面的復制被稱為淺復制(Shallow Copy)，還有一種稍微復雜的深度復制(deep copy)：

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

1. classAddress{
2. privateStringadd;
4. publicStringgetAdd(){
5. returnadd;
6. }
8. publicvoidsetAdd(Stringadd){
9. this.add=add;
10. }
12. }
14. classStudentimplementsCloneable{
15. privateintnumber;
17. privateAddressaddr;
19. publicAddressgetAddr(){
20. returnaddr;
21. }
23. publicvoidsetAddr(Addressaddr){
24. this.addr=addr;
25. }
27. publicintgetNumber(){
28. returnnumber;
29. }
31. publicvoidsetNumber(intnumber){
32. this.number=number;
33. }
35. @Override
36. publicObjectclone(){
37. Studentstu=null;
38. try{
39. stu=(Student)super.clone();
40. }catch(CloneNotSupportedExceptione){
41. e.printStackTrace();
42. }
43. returnstu;
44. }
45. }
46. publicclassTest{
48. publicstaticvoidmain(Stringargs[]){
50. Addressaddr=newAddress();
51. addr.setAdd("杭州市");
52. Studentstu1=newStudent();
53. stu1.setNumber(123);
54. stu1.setAddr(addr);
56. Studentstu2=(Student)stu1.clone();
58. System.out.println("學生1:"+stu1.getNumber()+",地址:"+stu1.getAddr().getAdd());
59. System.out.println("學生2:"+stu2.getNumber()+",地址:"+stu2.getAddr().getAdd());
60. }
61. }

打印結果：

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

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

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

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

打印結果：

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

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

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

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

1. packageabc;
3. classAddressimplementsCloneable{
4. privateStringadd;
6. publicStringgetAdd(){
7. returnadd;
8. }
10. publicvoidsetAdd(Stringadd){
11. this.add=add;
12. }
14. @Override
15. publicObjectclone(){
16. Addressaddr=null;
17. try{
18. addr=(Address)super.clone();
19. }catch(CloneNotSupportedExceptione){
20. e.printStackTrace();
21. }
22. returnaddr;
23. }
24. }
26. classStudentimplementsCloneable{
27. privateintnumber;
29. privateAddressaddr;
31. publicAddressgetAddr(){
32. returnaddr;
33. }
35. publicvoidsetAddr(Addressaddr){
36. this.addr=addr;
37. }
39. publicintgetNumber(){
40. returnnumber;
41. }
43. publicvoidsetNumber(intnumber){
44. this.number=number;
45. }
47. @Override
48. publicObjectclone(){
49. Studentstu=null;
50. try{
51. stu=(Student)super.clone();//淺復制
52. }catch(CloneNotSupportedExceptione){
53. e.printStackTrace();
54. }
55. stu.addr=(Address)addr.clone();//深度復制
56. returnstu;
57. }
58. }
59. publicclassTest{
61. publicstaticvoidmain(Stringargs[]){
63. Addressaddr=newAddress();
64. addr.setAdd("杭州市");
65. Studentstu1=newStudent();
66. stu1.setNumber(123);
67. stu1.setAddr(addr);
69. Studentstu2=(Student)stu1.clone();
71. System.out.println("學生1:"+stu1.getNumber()+",地址:"+stu1.getAddr().getAdd());
72. System.out.println("學生2:"+stu2.getNumber()+",地址:"+stu2.getAddr().getAdd());
74. addr.setAdd("西湖區");
76. System.out.println("學生1:"+stu1.getNumber()+",地址:"+stu1.getAddr().getAdd());
77. System.out.println("學生2:"+stu2.getNumber()+",地址:"+stu2.getAddr().getAdd());
78. }
79. }

打印結果：

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

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

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

java.util.Date:

1. /**
2. *Returnacopyofthisobject.
3. */
4. publicObjectclone(){
5. Dated=null;
6. try{
7. d=(Date)super.clone();
8. if(cdate!=null){
9. d.cdate=(BaseCalendar.Date)cdate.clone();
10. }
11. }catch(CloneNotSupportedExceptione){}//Won'thappen
12. returnd;
13. }

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

文章出自：http://blog.csdn.net/tounaobun/article/details/8491392