1.對象的復制
2.clone()的使用
3.對象實例的比較
////////////////////
//
/////////////////////

1.對象的復制

1.    
2. String str1 = "This is a string!"  //這里是 "對象引用" 的復制
3. String str2 = new String(str1);  //這里是 "對象實例" 的復制

淺復制: 只復制復合對象本身.
深復制: 除了復制復合對象本身, 還復制了復合對象的引用的對象實例.

例如:

1.  
2. class Pupil{
3.     public Pupil(String sno, String name, int age){
4.         this.sno = new String(sno);
5.         this.name = new String(name);
6.         this.age = age;
7.      }
8.  
9.     public String getSno() {
10.         return sno;
11.      }
12.  
13.     public String getName() {
14.         return 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.     private String sno;
26.     private String name;
27.     private int age;
28. }
29.  
30. public class CopyDemo {
31.     public static Pupil[] shallowCopy(Pupil[] aClass) {
32.          Pupil[] newClass = new Pupil[aClass.length];
33.  
34.         //此時newClass 與aClass 指向同一塊內存
35.         for(int i=0; i<aClass.length; i++)
36.              newClass[i] = aClass[i];
37.         return newClass;
38.      }
39.     
40.     public static Pupil[] deepCopy(Pupil[] aClass) {
41.          Pupil[] newClass = new Pupil[aClass.length];
42.  
43.         //此時newClass 與aClass 的相應sno , name 指向同一塊內存
44.         for(int i=0; i<aClass.length; i++) {
45.             String sno = aClass[i].getSno();
46.             String name = aClass[i].getName();
47.             int age = aClass[i].getAge();
48.              newClass[i] = new Pupil(sno, name, age);
49.          }
50.  
51.         return newClass;
52.      }
53.  
54.     public static Pupil[] deeperCopy(Pupil[] aClass) {
55.          Pupil[] newClass = new Pupil[aClass.length];
56.  
57.         //完全的復制
58.         for(int i=0; i<aClass.length; i++) {
59.             String sno = new String(aClass[i].getSno());
60.             String name = new String(aClass[i].getName());
61.             int age = aClass[i].getAge();
62.              newClass[i] = new Pupil(sno, name, age);
63.          }
64.  
65.         return newClass;
66.      }
67. }

2.clone()的使用

* Object.clone()
* Cloneable 接口
* CloneNotSupportedException

a. 使用Object.clone 進行復制
兩個必須條件:
1.一定要將重定義后的clone() 方法定義為公有方法(在Object 類中, 它是受保護的成員,     不能直接使用)
2.該后代類聲明實現接口 Cloneable 接口(當類實現該接口, 其任何子類也會繼承該接口), 該接口實際上沒有任何
   內容, 只是一個標識, 標志實現該接口的類提供clone() 方法.(這是接口的一種非典型用法)

1.  
2. public class Fraction implements Cloneable {
3.     public Object clone() {
4.         try{
5.             return super.clone();  //call protected method
6.          } catch (CloneNotSupportedException e) {
7.             return null;
8.          }
9.      }
10.     //other methods ...
11. }

b.重寫Object.clone()
例如對    private char[] cb; character buffer 進行復制
  

1. // add in class Cirbuf
2.         public Object clone() {
3.         try{
4.              Cirbuf copy = (Cirbuf)super.clone();
5.              copy.cb = (char[])cb.clone();
6.             return copy;
7.          }catch (CloneNotSupportedException e){
8.             throw new InternalError(e.toString());
9.          }
10.      }

c.復制數組
   數組是在方法調用重以引用的形式傳遞的對象. 下述情況下非常適合引用來傳遞數組:
   *正在接收的方法不修改數組
   *正在調用的方法不必關心是否修改數組
   *正在調用的方法想要得到數組中的修改結果
   否則, 就應該在方法調用中傳遞數組對象的副本. 只需調用 arrObj.clone() 方法即可完成數組arrObj 的復制操作. 隨后將該數組副本強制轉換為其正確類型:
       (type[])arrObj.clone();
    System.arraycopy 方法提供一種用于在數組間復制多個元素的有效方式.
         System.arraycopy(source, i, target, j, len)

3.對象實例的比較

例如:

1.  
2.      Pupil p1 = new Pupil("99184001", "zhang3", 18);
3.      Pupil p2 = new Pupil("99184001", "zhang3", 18);

a. "=="
    if(p1 == p2)...
   此次測試的是對象引用, 其結果肯定是false, 只要兩個對象引用不是互為別名就不會相等.
b. 淺比較   false

1.  
2.    if(p1.getSno() == p2.getSno() && p1.getName() == p2.getName()
3.       && p1.getAge() == p2.getAge()) ...;

c. 深比較    true[/code]  
   if(p1.getSno().equals(p2.getSno()) && p1.getName().equals(p2.getName())
      && p1.getAge() == p2.getAge()) ...;[/code]
     JAVA API 的跟類Object 也提供了equals() 方法, 但它只是比較兩個對象引用, 而非比較兩個對象實例.
     不管怎樣, 如果需要比較Pupil 類的對象(例如要將它們放入對象容器), 應該為Pupil 類重定義equals() 方法:

1.    
2.     public boolean equals(Object otherobj) {
3.         //檢查otherobj 是否為空
4.         if(otherobj == null) return false;
5.  
6.         //檢查otherobj 是否就是當前對象
7.         if(otherobj == this) return true;
8.  
9.         //檢查otherobj 是否具有正確的類型, 即檢查是否可與當前對象比較
10.         if(!(otherobj instanceof Pupil)) return false;
11.  
12.         //將otherobj 轉換為Pupil 類的對象引用
13.          Pupil tmpObj = (Pupil)otherobj;
14.         //關于學生是否相等的邏輯檢查
15.         if(sno.equals(tmpObj.sno) && name.equals(tmpObj.name)
16.               && age == tmpObj.age) return true;
17.         
18.         return false;
19.      }

    JAVA API 所提供的每個類幾乎都提供了采用深比較策略的equals() 方法, 例如String 類equals() 方法. 一般來說, 用戶自己定義的類也應當提供合適的equals() 方法, 特別是當程序要將其對象放入JAVA API 所提供的對象容器類的時候. 
    按照約定, 任何類所提供的equals() 方法所實現的相等比較應該是等價關系, 即滿足自反性, 對稱性和傳遞性. 另外一個類重定義了equals() 方法, 也應該重定義相應hashCode() 方法, 否則將這個類的對象放入映射對象容器時也會發生以外.