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

1 int n = 5;2 int m = n;

不僅僅是int類型，其它七種原始數據類型(boolean,char,byte,short,float,double.long)同樣適用于該類情況。但是如果你復制的是一個對象，情況就有些復雜了。

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

1 classStudent {2 private intnumber;3

4 public intgetNumber() {5 returnnumber;6 }7

8 public void setNumber(intnumber) {9 this.number =number;10 }11

12 }13 public classTest {14

15 public static voidmain(String args[]) {16

17 Student stu1 = newStudent();18 stu1.setNumber(12345);19 Student stu2 =stu1;20

21 System.out.println("學生1:" +stu1.getNumber());22 System.out.println("學生2:" +stu2.getNumber());23 }24 }

打印結果：

學生1:12345

學生2:12345

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

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

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

難道真的是這樣嗎？

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

1 stu2.setNumber(54321);2

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

打印結果:

學生1:54321

學生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 class Student implementsCloneable{2 private intnumber;3

4 public intgetNumber() {5 returnnumber;6 }7

8 public void setNumber(intnumber) {9 this.number =number;10 }11

12 @Override13 publicObject clone() {14 Student stu = null;15 try{16 stu = (Student)super.clone();17 }catch(CloneNotSupportedException e) {18 e.printStackTrace();19 }20 returnstu;21 }22 }23 public classTest {24

25 public static voidmain(String args[]) {26

27 Student stu1 = newStudent();28 stu1.setNumber(12345);29 Student stu2 =(Student)stu1.clone();30

31 System.out.println("學生1:" +stu1.getNumber());32 System.out.println("學生2:" +stu2.getNumber());33

34 stu2.setNumber(54321);35

36 System.out.println("學生1:" +stu1.getNumber());37 System.out.println("學生2:" +stu2.getNumber());38 }39 }

打印結果：

學生1:12345

學生2:12345

學生1:12345

學生2:54321

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

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

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

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

1 classAddress {2 privateString add;3

4 publicString getAdd() {5 returnadd;6 }7

8 public voidsetAdd(String add) {9 this.add =add;10 }11

12 }13

14 class Student implementsCloneable{15 private intnumber;16

17 privateAddress addr;18

19 publicAddress getAddr() {20 returnaddr;21 }22

23 public voidsetAddr(Address addr) {24 this.addr =addr;25 }26

27 public intgetNumber() {28 returnnumber;29 }30

31 public void setNumber(intnumber) {32 this.number =number;33 }34

35 @Override36 publicObject clone() {37 Student stu = null;38 try{39 stu = (Student)super.clone();40 }catch(CloneNotSupportedException e) {41 e.printStackTrace();42 }43 returnstu;44 }45 }46 public classTest {47

48 public static voidmain(String args[]) {49

50 Address addr = newAddress();51 addr.setAdd("杭州市");52 Student stu1 = newStudent();53 stu1.setNumber(123);54 stu1.setAddr(addr);55

56 Student stu2 =(Student)stu1.clone();57

58 System.out.println("學生1:" + stu1.getNumber() + ",地址:" +stu1.getAddr().getAdd());59 System.out.println("學生2:" + stu2.getNumber() + ",地址:" +stu2.getAddr().getAdd());60 }61 }

打印結果：

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

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

乍一看沒什么問題，真的是這樣嗎？我們在main方法中試著改變addr實例的地址。

1 addr.setAdd("西湖區");2

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

打印結果：

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

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

學生1:123,地址:西湖區

學生2:123,地址:西湖區

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

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

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

1 packageabc;2

3 class Address implementsCloneable {4 privateString add;5

6 publicString getAdd() {7 returnadd;8 }9

10 public voidsetAdd(String add) {11 this.add =add;12 }13

14 @Override15 publicObject clone() {16 Address addr = null;17 try{18 addr = (Address)super.clone();19 }catch(CloneNotSupportedException e) {20 e.printStackTrace();21 }22 returnaddr;23 }24 }25

26 class Student implementsCloneable{27 private intnumber;28

29 privateAddress addr;30

31 publicAddress getAddr() {32 returnaddr;33 }34

35 public voidsetAddr(Address addr) {36 this.addr =addr;37 }38

39 public intgetNumber() {40 returnnumber;41 }42

43 public void setNumber(intnumber) {44 this.number =number;45 }46

47 @Override48 publicObject clone() {49 Student stu = null;50 try{51 stu = (Student)super.clone(); //淺復制

52 }catch(CloneNotSupportedException e) {53 e.printStackTrace();54 }55 stu.addr = (Address)addr.clone(); //深度復制

56 returnstu;57 }58 }59 public classTest {60

61 public static voidmain(String args[]) {62

63 Address addr = newAddress();64 addr.setAdd("杭州市");65 Student stu1 = newStudent();66 stu1.setNumber(123);67 stu1.setAddr(addr);68

69 Student stu2 =(Student)stu1.clone();70

71 System.out.println("學生1:" + stu1.getNumber() + ",地址:" +stu1.getAddr().getAdd());72 System.out.println("學生2:" + stu2.getNumber() + ",地址:" +stu2.getAddr().getAdd());73

74 addr.setAdd("西湖區");75

76 System.out.println("學生1:" + stu1.getNumber() + ",地址:" +stu1.getAddr().getAdd());77 System.out.println("學生2:" + stu2.getNumber() + ",地址:" +stu2.getAddr().getAdd());78 }79 }

打印結果：

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

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

學生1:123,地址:西湖區

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

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

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

java.util.Date:

1 /**

2 * Return a copy of this object.3 */

4 publicObject clone() {5 Date d = null;6 try{7 d = (Date)super.clone();8 if (cdate != null) {9 d.cdate =(BaseCalendar.Date) cdate.clone();10 }11 } catch (CloneNotSupportedException e) {} //Won't happen

12 returnd;13 }

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

總結

以上是生活随笔為你收集整理的java复制一个对象_Java中对象的复制的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。