亚洲精品中文字幕无乱码_久久亚洲精品无码AV大片_最新国产免费Av网址_国产精品3级片

java語言

Java中的clone方法

時間:2024-08-15 03:34:38 java語言 我要投稿
  • 相關推薦

Java中的clone方法

  Java不僅吸收了C++語言的各種優(yōu)點,還摒棄了C++里難以理解的多繼承、指針等概念。那么大家知道Java中的clone方法是什么呢?下面一起來看看!

  Java中對象的創(chuàng)建

  clone顧名思義就是復制, 在Java語言中, clone方法被對象調用,所以會復制對象。所謂的復制對象,首先要分配一個和源對象同樣大小的空間,在這個空間中創(chuàng)建一個新的對象。那么在java語言中,有幾種方式可以創(chuàng)建對象呢?

  1 使用new操作符創(chuàng)建一個對象

  2 使用clone方法復制一個對象

  那么這兩種方式有什么相同和不同呢? new操作符的本意是分配內存。程序執(zhí)行到new操作符時, 首先去看new操作符后面的類型,因為知道了類型,才能知道要分配多大的內存空間。分配完內存之后,再調用構造函數,填充對象的各個域,這一步叫做對象的初始化,構造方法返回后,一個對象創(chuàng)建完畢,可以把他的引用(地址)發(fā)布到外部,在外部就可以使用這個引用操縱這個對象。而clone在第一步是和new相似的, 都是分配內存,調用clone方法時,分配的內存和源對象(即調用clone方法的對象)相同,然后再使用原對象中對應的各個域,填充新對象的域, 填充完成之后,clone方法返回,一個新的相同的對象被創(chuàng)建,同樣可以把這個新對象的引用發(fā)布到外部。

  復制對象 or 復制引用

  在Java中,以下類似的代碼非常常見:

  [java] view plain copyPerson p = new Person(23, "zhang");

  Person p1 = p;

  System.out.println(p);

  System.out.println(p1);

  當Person p1 = p;執(zhí)行之后, 是創(chuàng)建了一個新的對象嗎? 首先看打印結果:

  com.pansoft.zhangjg.testclone.Person@2f9ee1ac

  com.pansoft.zhangjg.testclone.Person@2f9ee1ac

  可已看出,打印的地址值是相同的,既然地址都是相同的,那么肯定是同一個對象。p和p1只是引用而已,他們都指向了一個相同的對象Person(23, "zhang") 。 可以把這種現象叫做引用的復制。 (關于引用和對象的區(qū)分,可以參考我之前的文章Java中的String為什么是不可變的? -- String源碼分析 , 其中有一節(jié)講到了引用和對象的區(qū)分)。上面代碼執(zhí)行完成之后, 內存中的情景如下圖所示:

  而下面的代碼是真真正正的克隆了一個對象。

  [java] view plain copyPerson p = new Person(23, "zhang");

  Person p1 = (Person) p.clone();

  System.out.println(p);

  System.out.println(p1);

  從打印結果可以看出,兩個對象的地址是不同的,也就是說創(chuàng)建了新的對象, 而不是把原對象的地址賦給了一個新的引用變量:

  com.pansoft.zhangjg.testclone.Person@2f9ee1ac

  com.pansoft.zhangjg.testclone.Person@67f1fba0

  以上代碼執(zhí)行完成后, 內存中的情景如下圖所示:

  深拷貝 or 淺拷貝

  上面的示例代碼中,Person中有兩個成員變量,分別是name和age, name是String類型, age是int類型。代碼非常簡單,如下所示:

  [java] view plain copypublic class Person implements Cloneable{

  private int age ;

  private String name;

  public Person(int age, String name) {

  this.age = age;

  this.name = name;

  }

  public Person() {}

  public int getAge() {

  return age;

  }

  public String getName() {

  return name;

  }

  @Override

  protected Object clone() throws CloneNotSupportedException {

  return (Person)super.clone();

  }

  }

  由于age是基本數據類型, 那么對它的拷貝沒有什么疑議,直接將一個4字節(jié)的整數值拷貝過來就行。但是name是String類型的, 它只是一個引用, 指向一個真正的String對象,那么對它的拷貝有兩種方式: 直接將源對象中的name的引用值拷貝給新對象的name字段, 或者是根據原Person對象中的name指向的字符串對象創(chuàng)建一個新的相同的字符串對象,將這個新字符串對象的引用賦給新拷貝的Person對象的name字段。這兩種拷貝方式分別叫做淺拷貝和深拷貝。深拷貝和淺拷貝的原理如下圖所示:

  下面通過代碼進行驗證。如果兩個Person對象的name的地址值相同, 說明兩個對象的name都指向同一個String對象, 也就是淺拷貝, 而如果兩個對象的name的地址值不同, 那么就說明指向不同的String對象, 也就是在拷貝Person對象的時候, 同時拷貝了name引用的String對象, 也就是深拷貝。驗證代碼如下:

  [java] view plain copyPerson p = new Person(23, "zhang");

  Person p1 = (Person) p.clone();

  String result = p.getName() == p1.getName()

  ? "clone是淺拷貝的" : "clone是深拷貝的";

  System.out.println(result);

  打印結果為:

  clone是淺拷貝的

  所以,clone方法執(zhí)行的是淺拷貝, 在編寫程序時要注意這個細節(jié)。

  覆蓋Object中的clone方法, 實現深拷貝

  現在為了要在clone對象時進行深拷貝, 那么就要Clonable接口,覆蓋并實現clone方法,除了調用父類中的clone方法得到新的對象, 還要將該類中的引用變量也clone出來。如果只是用Object中默認的clone方法,是淺拷貝的,再次以下面的代碼驗證:

  [java] view plain copystatic class Body implements Cloneable{

  public Head head;

  public Body() {}

  public Body(Head head) {this.head = head;}

  @Override

  protected Object clone() throws CloneNotSupportedException {

  return super.clone();

  }

  }

  static class Head /*implements Cloneable*/{

  public Face face;

  public Head() {}

  public Head(Face face){this.face = face;}

  }

  public static void main(String[] args) throws CloneNotSupportedException {

  Body body = new Body(new Head());

  Body body1 = (Body) body.clone();

  System.out.println("body == body1 : " + (body == body1) );

  System.out.println("body.head == body1.head : " + (body.head == body1.head));

  }

  在以上代碼中, 有兩個主要的類, 分別為Body和Face, 在Body類中, 組合了一個Face對象。當對Body對象進行clone時, 它組合的Face對象只進行淺拷貝。打印結果可以驗證該結論:

  body == body1 : false

  body.head == body1.head : true

  如果要使Body對象在clone時進行深拷貝, 那么就要在Body的clone方法中,將源對象引用的Head對象也clone一份。

  [java] view plain copystatic class Body implements Cloneable{

  public Head head;

  public Body() {}

  public Body(Head head) {this.head = head;}

  @Override

  protected Object clone() throws CloneNotSupportedException {

  Body newBody = (Body) super.clone();

  newBody.head = (Head) head.clone();

  return newBody;

  }

  }

  static class Head implements Cloneable{

  public Face face;

  public Head() {}

  public Head(Face face){this.face = face;}

  @Override

  protected Object clone() throws CloneNotSupportedException {

  return super.clone();

  }

  }

  public static void main(String[] args) throws CloneNotSupportedException {

  Body body = new Body(new Head());

  Body body1 = (Body) body.clone();

  System.out.println("body == body1 : " + (body == body1) );

  System.out.println("body.head == body1.head : " + (body.head == body1.head));

  }

  打印結果為:

  body == body1 : false

  body.head == body1.head : false

  由此可見, body和body1內的head引用指向了不同的Head對象, 也就是說在clone Body對象的同時, 也拷貝了它所引用的Head對象, 進行了深拷貝。

  真的是深拷貝嗎

  由上一節(jié)的內容可以得出如下結論:如果想要深拷貝一個對象, 這個對象必須要實現Cloneable接口,實現clone方法,并且在clone方法內部,把該對象引用的其他對象也要clone一份 , 這就要求這個被引用的對象必須也要實現Cloneable接口并且實現clone方法。

  那么,按照上面的結論, Body類組合了Head類, 而Head類組合了Face類,要想深拷貝Body類,必須在Body類的clone方法中將Head類也要拷貝一份,但是在拷貝Head類時,默認執(zhí)行的是淺拷貝,也就是說Head中組合的Face對象并不會被拷貝。驗證代碼如下:(這里本來只給出Face類的代碼就可以了, 但是為了閱讀起來具有連貫性,避免丟失上下文信息, 還是給出整個程序,整個程序也非常簡短)

  [java] view plain copystatic class Body implements Cloneable{

  public Head head;

  public Body() {}

  public Body(Head head) {this.head = head;}

  @Override

  protected Object clone() throws CloneNotSupportedException {

  Body newBody = (Body) super.clone();

  newBody.head = (Head) head.clone();

  return newBody;

  }

  }

  static class Head implements Cloneable{

  public Face face;

  public Head() {}

  public Head(Face face){this.face = face;}

  @Override

  protected Object clone() throws CloneNotSupportedException {

  return super.clone();

  }

  }

  static class Face{}

  public static void main(String[] args) throws CloneNotSupportedException {

  Body body = new Body(new Head(new Face()));

  Body body1 = (Body) body.clone();

  System.out.println("body == body1 : " + (body == body1) );

  System.out.println("body.head == body1.head : " + (body.head == body1.head));

  System.out.println("body.head.face == body1.head.face : " + (body.head.face == body1.head.face));

  }

  打印結果為:

  body == body1 : false

  body.head == body1.head : false

  body.head.face == body1.head.face : true

  內存結構圖如下圖所示:

  那么,對Body對象來說,算是這算是深拷貝嗎?其實應該算是深拷貝,因為對Body對象內所引用的其他對象(目前只有Head)都進行了拷貝,也就是說兩個獨立的Body對象內的head引用已經指向了獨立的兩個Head對象。但是,這對于兩個Head對象來說,他們指向了同一個Face對象,這就說明,兩個Body對象還是有一定的聯系,并沒有完全的獨立。這應該說是一種不徹底的深拷貝。

  如何進行徹底的深拷貝

  對于上面的例子來說,怎樣才能保證兩個Body對象完全獨立呢?只要在拷貝Head對象的時候,也將Face對象拷貝一份就可以了。這需要讓Face類也實現Cloneable接口,實現clone方法,并且在在Head對象的clone方法中,拷貝它所引用的Face對象。修改的部分代碼如下:

  [java] view plain copystatic class Head implements Cloneable{

  public Face face;

  public Head() {}

  public Head(Face face){this.face = face;}

  @Override

  protected Object clone() throws CloneNotSupportedException {

  //return super.clone();

  Head newHead = (Head) super.clone();

  newHead.face = (Face) this.face.clone();

  return newHead;

  }

  }

  static class Face implements Cloneable{

  @Override

  protected Object clone() throws CloneNotSupportedException {

  return super.clone();

  }

  }

  再次運行上面的示例,得到的運行結果如下:

  body == body1 : false

  body.head == body1.head : false

  body.head.face == body1.head.face : false

【Java中的clone方法】相關文章:

Java編程中異常處理的方法10-02

Java中操作Excel表格方法09-06

java中定義常量的方法及介紹08-27

JAVA中STRING的常用方法總結06-28

Java中的main()方法的使用講解10-31

Java編程中獲取路徑的方法09-06

Java的jar文件中讀取數據的方法09-27

java中BigDecimal的操作方法詳解06-28

關于Java中對象的銷毀方法分析09-03

java中set接口的使用方法07-09