內(nèi)容摘要

    若需修改一個(gè)對(duì)象，同時(shí)不想改變調(diào)用者的對(duì)象，就要制作該對(duì)象的一個(gè)本地副本，

java克隆對(duì)象clone()的用法和作用

。這也是本地副本最常見(jiàn)的一種用途。若決定制作一個(gè)本地副本，只需簡(jiǎn)單地使用clone()方法即可。Clone是“克隆”的意思，即制作完全一模一樣的副本。這個(gè)方法在基礎(chǔ)類Object中定義成“protected”（受保護(hù)）模式。但在希望克隆的任何衍生類中，必須將其覆蓋為“public”模式。例如，標(biāo)準(zhǔn)庫(kù)類Vector覆蓋了clone()，所以能為Vector調(diào)用clone()，

<code class="hljs" php="">寫(xiě)clone()方法時(shí)，通常都有一行代碼 super.clone();clone 有缺省行為，super.clone();因?yàn)槭紫纫�把父類中的成員復(fù)制到位，然后才是復(fù)制自己的成員。</code>

java克隆對(duì)象

    若需修改一個(gè)對(duì)象，同時(shí)不想改變調(diào)用者的對(duì)象，就要制作該對(duì)象的一個(gè)本地副本。這也是本地副本最常見(jiàn)的一種用途。若決定制作一個(gè)本地副本，只需簡(jiǎn)單地使用clone()方法即可。Clone是“克隆”的意思，即制作完全一模一樣的副本。這個(gè)方法在基礎(chǔ)類Object中定義成“protected”（受保護(hù)）模式。但在希望克隆的任何衍生類中，必須將其覆蓋為“public”模式。例如，標(biāo)準(zhǔn)庫(kù)類Vector覆蓋了clone()，所以能為Vector調(diào)用clone()，如下所示：

<code class="hljs" cs="">import java.util.*;class Int {  private int i;  public Int(int ii) { i = ii; }  public void increment() { i++; }  public String toString() {     return Integer.toString(i);   }}public class Cloning {  public static void main(String[] args) {    Vector v = new Vector();    for(int i = 0; i < 10; i++ )      v.addElement(new Int(i));    System.out.println(v:  + v);    Vector v2 = (Vector)v.clone();    for(Enumeration e = v2.elements();        e.hasMoreElements(); )      ((Int)e.nextElement()).increment();    System.out.println(v:  + v);  }}</code>

    clone()方法產(chǎn)生了一個(gè)Object，后者必須立即重新造型為正確類型。這個(gè)例子指出Vector的clone()方法不能自動(dòng)嘗試克隆Vector內(nèi)包含的每個(gè)對(duì)象——由于別名問(wèn)題，老的Vector和克隆的Vector都包含了相同的對(duì)象。我們通常把這種情況叫作“簡(jiǎn)單復(fù)制”或者“淺層復(fù)制”，因?yàn)樗�只�?fù)制了一個(gè)對(duì)象的“表面”部分。實(shí)際對(duì)象除包含這個(gè)“表面”以外，還包括句柄指向的所有對(duì)象，以及那些對(duì)象又指向的其他所有對(duì)象，由此類推。這便是“對(duì)象網(wǎng)”或“對(duì)象關(guān)系網(wǎng)”的由來(lái)。若能復(fù)制下所有這張網(wǎng)，便叫作“全面復(fù)制”或者“深層復(fù)制”。

    在輸出中可看到淺層復(fù)制的結(jié)果，注意對(duì)v2采取的行動(dòng)也會(huì)影響到v：

<code class="hljs" http="">v: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]v: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]</code>

    一般來(lái)說(shuō)，由于不敢保證Vector里包含的對(duì)象是“可以克隆”（注釋②）的，所以最好不要試圖克隆那些對(duì)象。

使類具有克隆能力

    盡管克隆方法是在所有類最基本的Object中定義的，但克隆仍然不會(huì)在每個(gè)類里自動(dòng)進(jìn)行。這似乎有些不可思議，因?yàn)榛�礎(chǔ)類方法在衍生類里是肯定能用的。但Java確實(shí)有點(diǎn)兒反其道而行之；如果想在一個(gè)類里使用克隆方法，唯一的辦法就是專門(mén)添加一些代碼，以便保證克隆的正常進(jìn)行。

    使用protected時(shí)的技巧

    為避免我們創(chuàng)建的每個(gè)類都默認(rèn)具有克隆能力，clone()方法在基礎(chǔ)類Object里得到了“保留”（設(shè)為protected）。這樣造成的后果就是：對(duì)那些簡(jiǎn)單地使用一下這個(gè)類的客戶程序員來(lái)說(shuō)，他們不會(huì)默認(rèn)地?fù)碛羞@個(gè)方法；其次，我們不能利用指向基礎(chǔ)類的一個(gè)句柄來(lái)調(diào)用clone()（盡管那樣做在某些情況下特別有用，比如用多形性的方式克隆一系列對(duì)象）。在編譯期的時(shí)候，這實(shí)際是通知我們對(duì)象不可克隆的一種方式——而且最奇怪的是，Java庫(kù)中的大多數(shù)類都不能克隆。因此，假如我們執(zhí)行下述代碼：

    Integer x = new Integer(l);

    x = x.clone();

    那么在編譯期，就有一條討厭的錯(cuò)誤消息彈出，告訴我們不可訪問(wèn)clone()——因?yàn)镮nteger并沒(méi)有覆蓋它，而且它對(duì)protected版本來(lái)說(shuō)是默認(rèn)的）。

    但是，假若我們是在一個(gè)從Object衍生出來(lái)的類中（所有類都是從Object衍生的），就有權(quán)調(diào)用Object.clone()，因?yàn)樗��?ldquo;protected”，而且我們?cè)谝粋�(gè)繼承器中�；�礎(chǔ)類clone()提供了一個(gè)有用的功能——它進(jìn)行的是對(duì)衍生類對(duì)象的真正“按位”復(fù)制，所以相當(dāng)于標(biāo)準(zhǔn)的克隆行動(dòng)。然而，我們隨后需要將自己的克隆操作設(shè)為public，否則無(wú)法訪問(wèn)�？傊�，克隆時(shí)要注意的兩個(gè)關(guān)鍵問(wèn)題是：幾乎肯定要調(diào)用super.clone()，以及注意將克隆設(shè)為public。

    有時(shí)還想在更深層的衍生類中覆蓋clone()，否則就直接使用我們的clone()（現(xiàn)在已成為public），而那并不一定是我們所希望的（然而，由于Object.clone()已制作了實(shí)際對(duì)象的一個(gè)副本，所以也有可能允許這種情況）。protected的技巧在這里只能用一次：首次從一個(gè)不具備克隆能力的類繼承，而且想使一個(gè)類變成“能夠克隆”。而在從我們的類繼承的任何場(chǎng)合，clone()方法都是可以使用的，因?yàn)镴ava不可能在衍生之后反而縮小方法的訪問(wèn)范圍。換言之，一旦對(duì)象變得可以克隆，從它衍生的任何東西都是能夠克隆的，除非使用特殊的機(jī)制（后面討論）令其“關(guān)閉”克隆能力。

    實(shí)現(xiàn)Cloneable接口

    為使一個(gè)對(duì)象的克隆能力功成圓滿，還需要做另一件事情：實(shí)現(xiàn)Cloneable接口。這個(gè)接口使人稍覺(jué)奇怪，因?yàn)樗�是空的�?/p>

    interface Cloneable {}

    之所以要實(shí)現(xiàn)這個(gè)空接口，顯然不是因?yàn)槲覀儨?zhǔn)備上溯造型成一個(gè)Cloneable，以及調(diào)用它的某個(gè)方法。有些人認(rèn)為在這里使用接口屬于一種“欺騙”行為，因?yàn)樗�使用的特性打的是別的主意，而非原來(lái)的意思。Cloneable interface的實(shí)現(xiàn)扮演了一個(gè)標(biāo)記的角色，封裝到類的類型中。

    兩方面的原因促成了Cloneable interface的存在。首先，可能有一個(gè)上溯造型句柄指向一個(gè)基礎(chǔ)類型，而且不知道它是否真的能克隆那個(gè)對(duì)象。在這種情況下，可用instanceof關(guān)鍵字（第11章有介紹）調(diào)查句柄是否確實(shí)同一個(gè)能克隆的對(duì)象連接：

    if(myHandle instanceof Cloneable) // …

    第二個(gè)原因是考慮到我們可能不愿所有對(duì)象類型都能克隆。所以O(shè)bject.clone()會(huì)驗(yàn)證一個(gè)類是否真的是實(shí)現(xiàn)了Cloneable接口。若答案是否定的，則“擲”出一個(gè)CloneNotSupportedException違例。所以在一般情況下，我們必須將“implement Cloneable”作為對(duì)克隆能力提供支持的一部分。

java的clone實(shí)現(xiàn)

    理解了實(shí)現(xiàn)clone()方法背后的所有細(xì)節(jié)后，便可創(chuàng)建出能方便復(fù)制的類，以便提供了一個(gè)本地副本：

<code class="hljs" cs="">import java.util.*;class MyObject implements Cloneable {  int i;  MyObject(int ii) { i = ii; }  public Object clone() {    Object o = null;    try {      o = super.clone();    } catch (CloneNotSupportedException e) {      System.out.println(MyObject can't clone);    }    return o;  }  public String toString() {    return Integer.toString(i);  }}public class LocalCopy {  static MyObject g(MyObject v) {     v.i++;    return v;  }  static MyObject f(MyObject v) {     v.i++;    return v;  }  public static void main(String[] args) {    MyObject a = new MyObject(11);    MyObject b = g(a);     if(a == b)       System.out.println(a == b);    else       System.out.println(a != b);    System.out.println(a =  + a);    System.out.println(b =  + b);    MyObject c = new MyObject(47);    MyObject d = f(c);    if(c == d)       System.out.println(c == d);    else       System.out.println(c != d);    System.out.println(c =  + c);    System.out.println(d =  + d);  }}</code>

    不管怎樣，clone()必須能夠訪問(wèn)，所以必須將其設(shè)為public（公共的）。其次，作為clone()的初期行動(dòng)，應(yīng)調(diào)用clone()的基礎(chǔ)類版本。這里調(diào)用的clone()是Object內(nèi)部預(yù)先定義好的。之所以能調(diào)用它，是由于它具有protected（受到保護(hù)的）屬性，所以能在衍生的類里訪問(wèn)。

    Object.clone()會(huì)檢查原先的對(duì)象有多大，再為新對(duì)象騰出足夠多的內(nèi)存，將所有二進(jìn)制位從原來(lái)的對(duì)象復(fù)制到新對(duì)象。這叫作“按位復(fù)制”，而且按一般的想法，這個(gè)工作應(yīng)該是由clone()方法來(lái)做的。但在Object.clone()正式開(kāi)始操作前，首先會(huì)檢查一個(gè)類是否Cloneable，即是否具有克隆能力——換言之，它是否實(shí)現(xiàn)了Cloneable接口。若未實(shí)現(xiàn)，Object.clone()就擲出一個(gè)CloneNotSupportedException違例，指出我們不能克隆它。因此，我們最好用一個(gè)try-catch塊將對(duì)super.clone()的調(diào)用代碼包圍（或封裝）起來(lái)，試圖捕獲一個(gè)應(yīng)當(dāng)永不出現(xiàn)的違例（因?yàn)檫@里確實(shí)已實(shí)現(xiàn)了Cloneable接口）。

    在LocalCopy中，兩個(gè)方法g()和f()揭示出兩種參數(shù)傳遞方法間的差異。其中，g()演示的是按引用傳遞，它會(huì)修改外部對(duì)象，并返回對(duì)那個(gè)外部對(duì)象的一個(gè)引用。而f()是對(duì)自變量進(jìn)行克隆，所以將其分離出來(lái)，并讓原來(lái)的對(duì)象保持獨(dú)立。隨后，它繼續(xù)做它希望的事情。甚至能返回指向這個(gè)新對(duì)象的一個(gè)句柄，而且不會(huì)對(duì)原來(lái)的對(duì)象產(chǎn)生任何副作用。注意下面這個(gè)多少有些古怪的語(yǔ)句：

    v = (MyObject)v.clone();

    它的作用正是創(chuàng)建一個(gè)本地副本。為避免被這樣的一個(gè)語(yǔ)句搞混淆，記住這種相當(dāng)奇怪的編碼形式在Java中是完全允許的，因?yàn)橛幸粋�(gè)名字的所有東西實(shí)際都是一個(gè)句柄。所以句柄v用于克隆一個(gè)它所指向的副本，而且最終返回指向基礎(chǔ)類型Object的一個(gè)句柄（因?yàn)樗�在Object.clone()中是那樣被定義的），隨后必須將其造型為正確的類型。

    在main()中，兩種不同參數(shù)傳遞方式的區(qū)別在于它們分別測(cè)試了一個(gè)不同的方法。輸出結(jié)果如下：

<code class="hljs" makefile="">a == ba = 12b = 12c != dc = 47d =48</code>

    大家要記住這樣一個(gè)事實(shí)：Java對(duì)“是否等價(jià)”的測(cè)試并不對(duì)所比較對(duì)象的內(nèi)部進(jìn)行檢查，從而核實(shí)它們的值是否相同。==和!=運(yùn)算符只是簡(jiǎn)單地對(duì)比句柄的內(nèi)容。若句柄內(nèi)的地址相同，就認(rèn)為句柄指向同樣的對(duì)象，所以認(rèn)為它們是“等價(jià)”的。所以運(yùn)算符真正檢測(cè)的是“由于別名問(wèn)題，句柄是否指向同一個(gè)對(duì)象？”

java Object.clone()的效果

    調(diào)用Object.clone()時(shí)，實(shí)際發(fā)生的是什么事情呢？當(dāng)我們?cè)谧约旱念惱锔采wclone()時(shí)，什么東西對(duì)于super.clone()來(lái)說(shuō)是最關(guān)鍵的呢？根類中的clone()方法負(fù)責(zé)建立正確的存儲(chǔ)容量，并通過(guò)“按位復(fù)制”將二進(jìn)制位從原始對(duì)象中復(fù)制到新對(duì)象的存儲(chǔ)空間。也就是說(shuō)，它并不只是預(yù)留存儲(chǔ)空間以及復(fù)制一個(gè)對(duì)象——實(shí)際需要調(diào)查出欲復(fù)制之對(duì)象的準(zhǔn)確大小，然后復(fù)制那個(gè)對(duì)象。由于所有這些工作都是在由根類定義之clone()方法的內(nèi)部代碼中進(jìn)行的（根類并不知道要從自己這里繼承出去什么），所以大家或許已經(jīng)猜到，這個(gè)過(guò)程需要用RTTI判斷欲克隆的對(duì)象的實(shí)際大小。采取這種方式，clone()方法便可建立起正確數(shù)量的存儲(chǔ)空間，并對(duì)那個(gè)類型進(jìn)行正確的按位復(fù)制。

    不管我們要做什么，克隆過(guò)程的第一個(gè)部分通常都應(yīng)該是調(diào)用super.clone()。通過(guò)進(jìn)行一次準(zhǔn)確的復(fù)制，這樣做可為后續(xù)的克隆進(jìn)程建立起一個(gè)良好的基礎(chǔ)。隨后，可采取另一些必要的操作，以完成最終的克隆。

    為確切了解其他操作是什么，首先要正確理解Object.clone()為我們帶來(lái)了什么。特別地，它會(huì)自動(dòng)克隆所有句柄指向的目標(biāo)嗎？下面這個(gè)例子可完成這種形式的檢測(cè)：

<code class="hljs" java="">public class Snake implements Cloneable {  private Snake next;  private char c;   Snake(int i, char x) {    c = x;    if(--i > 0)      next = new Snake(i, (char)(x + 1));  }  void increment() {    c++;    if(next != null)      next.increment();  }  public String toString() {    String s = : + c;    if(next != null)      s += next.toString();    return s;  }  public Object clone() {    Object o = null;    try {      o = super.clone();    } catch (CloneNotSupportedException e) {}    return o;  }  public static void main(String[] args) {    Snake s = new Snake(5, 'a');    System.out.println(s =  + s);    Snake s2 = (Snake)s.clone();    System.out.println(s2 =  + s2);    s.increment();    System.out.println(      after s.increment, s2 =  + s2);  }}</code>

    一條Snake（蛇）由數(shù)段構(gòu)成，每一段的類型都是Snake，

電腦資料

《java克隆對(duì)象clone()的用法和作用》(http://www.shangyepx.com)。所以，這是一個(gè)一段段鏈接起來(lái)的列表。所有段都是以循環(huán)方式創(chuàng)建的，每做好一段，都會(huì)使第一個(gè)構(gòu)建器參數(shù)的值遞減，直至最終為零。而為給每段賦予一個(gè)獨(dú)一無(wú)二的標(biāo)記，第二個(gè)參數(shù)（一個(gè)Char）的值在每次循環(huán)構(gòu)建器調(diào)用時(shí)都會(huì)遞增。

    increment()方法的作用是循環(huán)遞增每個(gè)標(biāo)記，使我們能看到發(fā)生的變化；而toString則循環(huán)打印出每個(gè)標(biāo)記。輸出如下：

    s = :a:b:c:d:e

    s2 = :a:b:c:d:e

    after s.increment, s2 = :a:c:d:e:f

    這意味著只有第一段才是由Object.clone()復(fù)制的，所以此時(shí)進(jìn)行的是一種“淺層復(fù)制”。若希望復(fù)制整條蛇——即進(jìn)行“深層復(fù)制”——必須在被覆蓋的clone()里采取附加的操作。

    通�？稍趶囊粋�(gè)能克隆的類里調(diào)用super.clone()，以確保所有基礎(chǔ)類行動(dòng)（包括Object.clone()）能夠進(jìn)行。隨著是為對(duì)象內(nèi)每個(gè)句柄都明確調(diào)用一個(gè)clone()；否則那些句柄會(huì)別名變成原始對(duì)象的句柄。構(gòu)建器的調(diào)用也大致相同——首先構(gòu)造基礎(chǔ)類，然后是下一個(gè)衍生的構(gòu)建器……以此類推，直到位于最深層的衍生構(gòu)建器。區(qū)別在于clone()并不是個(gè)構(gòu)建器，所以沒(méi)有辦法實(shí)現(xiàn)自動(dòng)克隆。為了克隆，必須由自己明確進(jìn)行。

克隆合成對(duì)象

    試圖深層復(fù)制合成對(duì)象時(shí)會(huì)遇到一個(gè)問(wèn)題。必須假定成員對(duì)象中的clone()方法也能依次對(duì)自己的句柄進(jìn)行深層復(fù)制，以此類推。這使我們的操作變得復(fù)雜。為了能正常實(shí)現(xiàn)深層復(fù)制，必須對(duì)所有類中的代碼進(jìn)行控制，或者至少全面掌握深層復(fù)制中需要涉及的類，確保它們自己的深層復(fù)制能正確進(jìn)行。

    下面這個(gè)例子總結(jié)了面對(duì)一個(gè)合成對(duì)象進(jìn)行深層復(fù)制時(shí)需要做哪些事情：

<code axapta="" class="hljs">class DepthReading implements Cloneable {  private double depth;  public DepthReading(double depth) {     this.depth = depth;  }  public Object clone() {    Object o = null;    try {      o = super.clone();    } catch (CloneNotSupportedException e) {      e.printStackTrace();    }    return o;  }}class TemperatureReading implements Cloneable {  private long time;  private double temperature;  public TemperatureReading(double temperature) {    time = System.currentTimeMillis();    this.temperature = temperature;  }  public Object clone() {    Object o = null;    try {      o = super.clone();    } catch (CloneNotSupportedException e) {      e.printStackTrace();    }    return o;  }}class OceanReading implements Cloneable {  private DepthReading depth;  private TemperatureReading temperature;  public OceanReading(double tdata, double ddata){    temperature = new TemperatureReading(tdata);    depth = new DepthReading(ddata);  }  public Object clone() {    OceanReading o = null;    try {      o = (OceanReading)super.clone();    } catch (CloneNotSupportedException e) {      e.printStackTrace();    }    o.depth = (DepthReading)o.depth.clone();    o.temperature =       (TemperatureReading)o.temperature.clone();    return o;   }}public class DeepCopy {  public static void main(String[] args) {    OceanReading reading =       new OceanReading(33.9, 100.5);    OceanReading r =       (OceanReading)reading.clone();  }}</code>

    DepthReading和TemperatureReading非常相似；它們都只包含了基本數(shù)據(jù)類型。所以clone()方法能夠非常簡(jiǎn)單：調(diào)用super.clone()并返回結(jié)果即可。注意兩個(gè)類使用的clone()代碼是完全一致的。

    OceanReading是由DepthReading和TemperatureReading對(duì)象合并而成的。為了對(duì)其進(jìn)行深層復(fù)制，clone()必須同時(shí)克隆OceanReading內(nèi)的句柄。為達(dá)到這個(gè)目標(biāo)，super.clone()的結(jié)果必須造型成一個(gè)OceanReading對(duì)象（以便訪問(wèn)depth和temperature句柄）。

    java.lang.Object里面有一個(gè)方法clone()

    protected Object clone()

    throws CloneNotSupportedException創(chuàng)建并返回此對(duì)象的一個(gè)副本。“副本”的準(zhǔn)確含義可能依賴于對(duì)象的類。這樣做的目的是，對(duì)于任何對(duì)象 x，表達(dá)式：

    x.clone() != x為 true，表達(dá)式：

    x.clone().getClass() == x.getClass()也為 true，但這些并非必須要滿足的要求。一般情況下：

    x.clone().equals(x)為 true，但這并非必須要滿足的要求。

    按照慣例，返回的對(duì)象應(yīng)該通過(guò)調(diào)用 super.clone 獲得。如果一個(gè)類及其所有的超類（Object 除外）都遵守此約定，則 x.clone().getClass() == x.getClass()。

    按照慣例，此方法返回的對(duì)象應(yīng)該獨(dú)立于該對(duì)象（正被復(fù)制的對(duì)象）。要獲得此獨(dú)立性，在 super.clone 返回對(duì)象之前，有必要對(duì)該對(duì)象的一個(gè)或多個(gè)字段進(jìn)行修改。這通常意味著要復(fù)制包含正在被復(fù)制對(duì)象的內(nèi)部“深層結(jié)構(gòu)”的所有可變對(duì)象，并使用對(duì)副本的引用替換對(duì)這些對(duì)象的引用。如果一個(gè)類只包含基本字段或?qū)Σ蛔儗?duì)象的引用，那么通常不需要修改 super.clone 返回的對(duì)象中的字段。

    Object 類的 clone 方法執(zhí)行特定的復(fù)制操作。首先，如果此對(duì)象的類不能實(shí)現(xiàn)接口 Cloneable，則會(huì)拋出 CloneNotSupportedException。注意，所有的數(shù)組都被視為實(shí)現(xiàn)接口 Cloneable。否則，此方法會(huì)創(chuàng)建此對(duì)象的類的一個(gè)新實(shí)例，并像通過(guò)分配那樣，嚴(yán)格使用此對(duì)象相應(yīng)字段的內(nèi)容初始化該對(duì)象的所有字段；這些字段的內(nèi)容沒(méi)有被自我復(fù)制。所以，此方法執(zhí)行的是該對(duì)象的“淺表復(fù)制”，而不“深層復(fù)制”操作。

    Object 類本身不實(shí)現(xiàn)接口 Cloneable，所以在類為 Object 的對(duì)象上調(diào)用 clone 方法將會(huì)導(dǎo)致在運(yùn)行時(shí)拋出異常。

    返回：

    此實(shí)例的一個(gè)副本。

    拋出：

    CloneNotSupportedException - 如果對(duì)象的類不支持 Cloneable 接口，則重寫(xiě) clone 方法的子類也會(huì)拋出此異常，以指示無(wú)法復(fù)制某個(gè)實(shí)例。

<code>其實(shí)clone()被定義為protected是有原因的,因?yàn)橛行�時(shí)候某些類實(shí)例我們不希望能被復(fù)制.那我們?cè)趺从眠@個(gè)方法呢?只要使用一個(gè)super關(guān)鍵字就夠了.下面例子可以解釋清楚clone()的作用與其用法:</code>

<code avrasm="" class="hljs">public class C  {     static class Strings implements Cloneable     {         private String str;         public void SetStr(String s){             this.str = s;        }        public String GetStr(){            return this.str;        }        public Object clone()throws CloneNotSupportedException{            return super.clone();        }    }    public static void main(String[] args)     {        try{            Strings str1 = new Strings();            str1.SetStr(Hello World!);            System.out.println(-----------------);            System.out.println(str1.SetStr(Hello World!););            System.out.println(str2 = (Strings)str1.clone(););            Strings str2 = (Strings)str1.clone();            System.out.println(str1:+str1.GetStr());            System.out.println(str2:+str2.GetStr());            System.out.print(print object str1:);            System.out.println(str1);            System.out.print(print object str2:);            System.out.println(str2);            System.out.println(-----------------);            System.out.println(str2.setStr(Hello!););            str2.SetStr(Hello!);            System.out.println(str1:+str1.GetStr());            System.out.println(str2:+str2.GetStr());            System.out.print(print object str1:);            System.out.println(str1);            System.out.print(print object str2:);            System.out.println(str2);            System.out.println(-----------------);            System.out.println(str1 = str2;);            str1 = str2;            System.out.print(print object str1:);            System.out.println(str1);            System.out.print(print object str2:);            System.out.println(str2);            System.out.println(-----------------);        }catch(Exception ex){            System.out.println(ex.toString());        }    }}</code>

    運(yùn)行結(jié)果如下：

<code asciidoc="" class="hljs">-----------------str1.SetStr(Hello World!);str2 = (Strings)str1.clone();str1:Hello World!str2:Hello World!print object str1:C$Strings@de6cedprint object str2:C$Strings@c17164-----------------str2.setStr(Hello!);str1:Hello World!str2:Hello!print object str1:C$Strings@de6cedprint object str2:C$Strings@c17164-----------------str1 = str2;print object str1:C$Strings@c17164print object str2:C$Strings@c17164-----------------</code>