關於Object類中的方法，根據其所涉及的知識點，分為如下4個部分：

• 基礎
  • clone : protected Object clone() throws CloneNotSupportedException
  • equals : public boolean equals?(Object obj)
  • hashCode : public int hashCode()
  • toString : public String toString()
• 反射
  
  • getClass : public final Class<?> getClass()
• 線程
  • wait
    • public final void wait() throws InterruptedException
    • public final void wait?(long timeout) throws InterruptedException
    • public final void wait?(long timeout,int nanos) throws InterruptedException
  • notify : public final void notify()
  • notifyAll : public final void notifyAll()
• JVM
  • finalize : protected void finalize() throws Throwable

2018-09-15

今天寫：equals、hashCode、toString、clone、getClass，後面的方法等學到相關知識再作補充。

一. equals

public boolean equals(Object obj) {
    return (this == obj);
}

equals用來判斷兩個對象是否”相等“，而對“相等

• 1. Object類中的equals使用 this == obj 來定義相等，即：兩個引用是否指向同一個對象；
• 2. 有些時候，我們並不需要定義如此嚴格的相等，比如：定義一個Point類，只要兩個點的橫縱坐標分別相等，我們就認為它們相等；

要實現上面的需求，我們就需要重寫equals方法，如下：

public class Point {
    int x;
    int y;
    
    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj instanceof Point) {
            Point p = (Point)obj;
            return (this.x == p.x && this.y == p.y);
        }
        return false;
    }
}

測試：

public static void main(String[] args) {
    Point p1 = new Point(1, 1);
    Point p2 = new Point(1, 1);
    System.out.println("p1.equals(p2) : " + p1.equals(p2));
    p2.x = 2;
    System.out.println("p1.equals(p2) : " + p1.equals(p2));
}
/* 輸出
p1.equals(p2) : true
p1.equals(p2) : false
*/

另記：String類也重寫了equals方法，實現了：只要兩個字符串長度相等及字符串中對應位置的字符相等，則兩字符串相等。可以參考String類中的equals方法。

註意：在重寫equals方法時，方法定義要寫為：public boolean equals(Object obj) {....} ，參數類型是：Object obj

二. hashCode

public native int hashCode();

hashCode，官方解釋：返回對象的一個哈希碼，為基於哈希表的數據結構提供便利，如：HashMap等。

Object類中的hashCode方法為本地方法，在重寫hashCode方法時，需遵循以下規則：

• 1. 在對象equals比較中使用的信息未被修改的前提下，在Java程序運行期間，同一個對象多次調用（不同時間）應該始終返回同一個整數。在程序不同的運行期間，返回的整數不需要保持一致；
• 2. 如果兩個對象調用 equals(Object obj) 時相等，那麽這兩個對象在調用 hashCode 時應該返回同一個整數值；
• 3. 並不要求為調用 equals(Object obj) 時不相等的兩個對象，返回兩個不同的哈希碼。只不過為不相等的對象返回不同的哈希碼可以提高哈希表的性能；

關於第2條規則，我們繼續Point類這個例子。首先，在未重寫hashCode方法的情況下，我們測試兩個對象的hashCode()輸出值：

public static void main(String[] args) {
    Point p1 = new Point(9483, 89382);
    Point p2 = new Point(9483, 89382);
    System.out.println("p1.hashCode() : " + p1.hashCode());
    System.out.println("p2.hashCode() : " + p2.hashCode());
}
/* 輸出：
p1.hashCode() : 166239592
p2.hashCode() : 991505714
*/

可以看到，在我們定義的equals方法下相等的兩個對象，得到的hashCode是不同的，如此不一致會造成什麽後果呢？我們知道 HashMap 在存儲<Key, Value>時，如果Key1等於Key2，那麽存儲的鍵值對為：<Key1, Value2>，即：只會存儲一個Key，使用的是最新的Value。而 HashMap 中在判斷 Key1是否等於Key2時，使用的就是它們的hashCode。在未重寫hashCode方法的情況下，看如下測試：

public static void main(String[] args) {
    Point p1 = new Point(9483, 89382);
    Point p2 = new Point(9483, 89382);
    
    HashMap<Point, Integer> map = new HashMap<Point, Integer>();
    map.put(p1, p1.hashCode());
    map.put(p2, p2.hashCode());
    for (Map.Entry<Point, Integer> m : map.entrySet()) {
        System.err.println(m);
    }
}
/* 輸出
Point@9e89d68=166239592
Point@3b192d32=991505714
*/

根據我們對Point類相等的定義，p1與p2相等，而在 HashMap 中卻存入了兩個鍵值對，顯然不符合我們的意圖。（equals與hashCode的不一致，會造成使用時產生歧義，從而導致意想不到的錯誤。所以，我們在重寫equals方法後，也要重寫hashCode方法，使其意義一致）現在我們來重寫hashCode方法，再進行如上測試：

@Override
public int hashCode() {
    return (x & y) | (x ^ y);
}
/* 輸出
Point@17d2f=97583
*/

根據我們對hashCode方法的定義，對象的hashCode只與(x, y)相關，所以 p1.hashCode() == p2.hashCode() 為 true。這樣一來，HashMap 中只會存入一個鍵值對，符合我們的預期。

三. toString

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

源碼中直接返回：對象類型名@對象hashCode的十六進制，舉個例子：

public static void main(String[] args) {
    Point p1 = new Point(9483, 89382);
    System.out.println(p1.toString());
}
/* 輸出
Point@17d2f
*/

很多情況下，我們都要重寫toString()方法，就比如Point類，我們想知道的是點的橫縱坐標(x, y)，而不是 Point@17d2f 這串不知所雲的字符。

@Override
public String toString() {
    return "(" + x + ", " + y + ")";
}
/* 輸出
(9483, 89382)
*/

四. clone

protected native Object clone() throws CloneNotSupportedException;

從方法定義入手：

• 1. protected，表明只有本類及其子類可以使用該方法來克隆對象，子類可以重寫該方法；
• 2. native，表明Object類中clone是本地方法；
• 3. CloneNotSupportedException，如果調用clone方法的對象的類沒有 implememnts Cloneable，就會拋出這個異常；

現在，我們對之前的Point類進行部分修改，為了節省空間，我只貼出修改部分的代碼：

首先，定義Data類，用來記錄一個點所包含的相關信息；

public class Data {
    int weight;
    String name;
    
    Data(int weight, String name) {
        this.weight = weight;
        this.name = name;
    }
}

然後，Point類實現Cloneable接口，並且Point類中包含一個Data類型字段，如下：

public class Point implements Cloneable {
    int x;
    int y;
    Data data;

    Point(int x, int y, Data data) {
        this.x = x;
        this.y = y;
        this.data = data;
    }
    ...
}

測試：

public static void main(String[] args) throws Exception {
    Data data = new Data(20, "A");
    Point p1 = new Point(1, 2, data);
    Point p2 = (Point)p1.clone();
    
    System.out.println("p1 == p2 : " + (p1 == p2));
    System.out.println("p1.(x, y) = " + p1.toString() + ", p2.(x, y) = " + p2.toString());
    System.out.println("p1.data == p2.data : " + (p1.data == p2.data));
}
/* 輸出
p1 == p2 : false
p1.(x, y) = (1, 2), p2.(x, y) = (1, 2)
p1.data == p2.data : true
*/

對於測試的輸出，我們可以發現：

• 1. p1 == p2 為 false，說明 p1.clone() 重新生成了一個對象；
• 2. p1.(x, y) 等於 p2.(x, y)，說明 p1.clone() 會把原對象的基礎數據類型字段的值拷貝給生成的新對象的對應字段；
• 3. p1.data == p2.data 為 true，說明引用類型字段，新對象的字段與原對象的字段引用同一個對象；

對於第3條，即Object類的clone方法是淺拷貝，理解如圖：

在一些並發編程情景下，我們常常需要操作 不可變對象 來保證並發安全性。不可變對象，顧名思義就是你創建的對象不會改變，你可以理解為：

• 1. 對象本身就是不可變的，如：字段都是final修飾等；
• 2. 對象本身可變，但是我們在使用的時候不會去改變它，即人為的不可變；

（更詳細的內容，可以參考《Java並發編程實戰》）

現在，假如我要在並發環境下使用p1.clone()出來的對象p2，並要求p2是不可變的。而事實上，其他線程可以通過 p1.data 來改變 p2.data 的狀態，以破壞p2的不可變性。

要想使p2不可變，我們就需要對Point類進行深拷貝，即：對Piont類中的Data類型字段也創建一個新的對象，使得 p1.data != p2.data，如下：

public class Data {
    ...
    // 自定義的clone()，並非重寫Object類中的clone()
    public Data clone() {
        return new Data(weight, name);
    }
}
public class Point implements Cloneable {
    ...
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Point p = (Point)super.clone();
        p.data = data.clone(); // 這裏的data.clone()與Object類中的clone()無關
        return p;
    }
    ...
}
/* 重復上面的測試，輸出：
p1 == p2 : false
p1.(x, y) = (1, 2), p2.(x, y) = (1, 2)
p1.data == p2.data : false
*/

思考：如果一個類中一直嵌套著包含引用類型字段，那麽我們該怎麽才能做到深拷貝呢？很明顯，對於類中每一個引用類型對象都做深拷貝。（遞歸處理）

五. getClass

public final native Class<?> getClass();

getClass方法，返回對象的類對象，在反射中經常使用，例如：

Data類中有個私有方法 printInfo()，該方法在Point類中無法正常調用，但是我們可以通過反射機制來調用該方法。

public class Data {
    ...
    private void printInfo() {
        System.out.println("weight = " + weight);
        System.out.println("name : " + name);
    }
}
// 在Point類中
public static void main(String[] args) throws Exception {
    Data data = new Data(20, "A");
    Class<?> clz = data.getClass();
    Method m = clz.getDeclaredMethod("printInfo");
    m.setAccessible(true); // 抑制Java的訪問控制檢查
    m.invoke(data);
}
/* 輸出
weight = 20
name : A
*/

這裏只是簡單提一下，更多關於反射的知識，會在後期總結。

Java - Obejct 類 （待續）