重寫equals方法的正確打開方式

正文開始@Assassin

1. 什么是equals方法？

我們首先得知道，Object類是 Java中所有類的父類(超類/基類)，也就是說，在Java中，所有的類都是默認繼承自Object類的，換言之，Object類中所實作的方法我們都可以直接拿來用，而equals方法便是Object類所實作的眾多方法之一，

以下截圖自Java11 API

Object類的所有方法：

1.1 equals方法：

• equals：是Object類中的方法，只能判斷參考型別，等下可以帶大伙看看jdk原始碼
• 默認判斷的是地址是否相等（因為參考型別變數底層本質就是來存盤物件地址的，有C/C++知識的小伙伴應該很了解 ），在子類中往往會重寫該方法，用于判斷物件的內容是否相等，比如等下會簡單了解到的Integer和String(在IDEA里看原始碼實作 )

2. 為什么要重寫equals方法？

我們有Object類實作的equals方法能用不就行了？為啥還得重寫equals方法呢？這就要看看Object類的equals方法實作機制了，

我們可以清楚地看到，Object類的equals方法底層是用 == 來實作的，也就是說它的用法跟我們平常用來比較基本資料型別的 == 用法一致，我們首先來看一下 == 的語法：

• == 只能用來比較基本資料型別是否相等，也就是單純的值比較；
• == 在比較浮點數的時候也可能存在失效的情況，這是因為浮點數的存盤機制跟整型家族不一樣，浮點數本身就不能表示一個精確的值（具體原因可自行查看IEEE 754規則，這里不再展開）

所以我們在單純的進行基本資料型別的值比較時可以用 == ，而比較參考資料型別就不能這么做，前面有提到，參考資料型別本質上是來參考/存盤物件的地址的，所有你完全可以把它當做C/C++的指標來看待（這里杠一句說Java沒有指標的，個人覺得只是叫法不同罷了 ）
注： 不要把Java參考跟C++參考搞混了，C++參考其實是指標常量，即int* const，這也是C++的參考只能作為一個變數的別名的原因，

2.1 舉個例子吧~

比較兩個int時可以直接用 == ，當它們相等時結果為true，而當new了兩個屬性完全一樣的物件時，再用 == 來進行比較就會出現錯誤，如我們所見，明明我們應該想要得到true的，結果卻是false
原始碼：

運行結果：

到這里，我們應該大致清楚為啥要在比較物件時重寫equals方法了，因為Object類提供給我們的不好使~~

3. 分析equals原始碼：

在進行重寫之前，我們依舊來看看Java API中的定義：
public boolean equals?(Object obj)
作用：指示某個其他物件是否“等于”此物件，

equals方法在非null物件參考上實作等價關系：

• 自反性 ：對于任何非空的參考值x ， x.equals(x)應該回傳true ，
• 對稱性 ：對于任何非空參考值x和y ， x.equals(y)應該回傳true當且僅當y.equals(x)回報true ，
• 傳遞性 ：對于任何非空參考值x ， y和z ，如果x.equals(y)回報true個y.equals(z)回報true ，然后x.equals(z)應該回傳true ，
• 一致性 ：對于任何非空參考值x和y ，多次呼叫x.equals(y)始侄訓傳true或始侄訓傳false ，前提是未修改物件上的equals比較中使用的資訊，
• 對于任何非空的參考值x ， x.equals(null)應該回傳false，

類Object的equals方法實作了物件上最具區別的可能等價關系; 也就是說，對于任何非空參考值x和y ，當且僅當x和y參考同一物件（ x == y具有值true ）時，此方法回傳true ，

注意：通常需要在重寫此方法時覆寫hashCode方法，以便維護hashCode方法的常規協定，該方法宣告相等物件必須具有相等的哈希代碼，

接下來看看String類中重寫的equals方法和Integer類中重寫的equals方法：

//String類equals源代碼：
public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

簡單解讀一下就是當對比的是同一個物件時，直接回傳true，提高效率，當傳進來的物件是當前類的實體時，進入進一步的判斷，一個for回圈依次遍歷字串每一個字符，只要有一個字符不同就回傳false，

繼續來看看Integer類的equals源代碼：

//Integer類的equals源代碼:
 public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

Integer類的equals原始碼簡單許多，只要傳入的物件是當前類的實體，就進行進一步的判斷：當它們的值相等時，就回傳true，不相等就回傳false，

這里還是來實際演示一下⑧，就以Integer類為例：

很明顯，我們知道Integer類重寫了equals方法且是參考型別，當直接用 == 來比較參考型別變數時，結果是false，而用equals判斷結果為true，這便很好地說明了重寫equals方法的必要性，String類大伙自己驗證一哈⑧，

4. 正確重寫equals方法：

（先說結論，getClass()比instanceof更安全）

到這里，我們基本把equals方法的各種原始碼都分析了一遍，接下來就是我們自己要來實作equals方法了，

這里提供兩個比較常見的equals重寫方法：

• 用instanceof實作重寫equals方法
• 用getClass實作重寫equals方法

假設有此場景：

在已經創建好的長方形類中重寫Object類中的equals方法為當長方形的長和寬相等時，回傳TRUE，同時重寫hashCode方法，重寫toString方法為顯示長方形的長寬資訊，并測驗類，

package com.test10_04;

import java.util.Objects;

class Rectangle {
    private double length;
    private double wide;

    public Rectangle() {
        //空實作
    }
    public Rectangle(double length, double wide) {
        setLength(length);
        setWide(wide);
    }

    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        assert length > 0.0 : "您的輸入有誤，長方形的長不能小于0";
        this.length = length;
    }

    public double getWide() {
        return wide;
    }

    public void setWide(double wide) {
        assert wide > 0.0 : "您的輸入有誤，長方形的寬不能小于0";
        this.wide = wide;
    }

    public double area() {
        return this.length * this.wide;

    }
    public double circumference() {
        return 2 * (this.wide + this.length);
    }

    public boolean equals(Object obj) {
        if (this == obj) { //判斷一下如果是同一個物件直接回傳true，提高效率
            return true;
        }
        if (obj == null || obj.getClass() != this.getClass()) { //如果傳進來的物件為null或者二者為不同類，直接回傳false
            return false;
        }
        //也可以以下方法：
//        if (obj == null || !(obj instanceof Rectangle)) { //如果傳進來的物件為null或者二者為不同類，直接回傳false
//            return false;
//        }
        Rectangle rectangle = (Rectangle) obj; //向下轉型
        //比較長寬是否相等，注意：浮點數的比較不能簡單地用==，會有精度的誤差，用Math.abs或者Double.compare
        return Double.compare(rectangle.length, length) == 0 && Double.compare(rectangle.wide, wide) == 0;
    }

    public int hashCode() { //重寫equals的同時也要重寫hashCode，因為同一物件的hashCode永遠相等
        return Objects.hash(length, wide); //呼叫Objects類，這是Object類的子類
    }

    public String toString() {
        return "Rectangle{" + "length=" + length + ", wide=" + wide + '}';
    }
}

public class TestDemo {
    public static void main(String[] args) {

        Rectangle rectangle1 = new Rectangle(3.0, 2.0);
        Rectangle rectangle2 = new Rectangle(3.0, 2.0);
        
        System.out.println(rectangle1.equals(rectangle2));
        System.out.println("rectangle1哈希碼:" + rectangle1.hashCode() +
                "\nrectangle2哈希碼:" + rectangle2.hashCode());
        System.out.println("toString列印資訊：" + rectangle1.toString());
    }
}

具體實作思路在代碼中講的很清楚了，我們這里重點分析一下getClass和instanceof兩種實作方法的優缺點：

將代碼邏輯簡化一下：
我們就重點看這段簡單的代碼

//getClass()版本
public class Student {
	private String name;
	
    public void setName(String name) {
        this.name = name;
    }
	@Override
	public boolean equals(Object object){
		if (object == this)
			return true;
		// 使用getClass()判斷物件是否屬于該類
		if (object == null || object.getClass() != getClass())
			return false;
		Student student = (Student)object;
		return name != null && name.equals(student.name);
}

//instanceof版本
public class Student {
	private String name;
	
    public void setName(String name) {
       this.name = name;
   }
	@Override
	public boolean equals(Object object){
		if (object == this)
			return true;
		// 通過instanceof來判斷物件是否屬于類
		if (object == null || !(object instanceof Student))
			return false;
		Student student = (Student)object;
		return name!=null && name.equals(student.name);
	}
}

事實上兩種方案都是有效的，區別就是getClass()限制了物件只能是同一個類，而instanceof卻允許物件是同一個類或其子類，這樣equals方法就變成了父類與子類也可進行equals操作了，這時候如果子類重定義了equals方法，那么就可能變成父類物件equlas子類物件為true，但是子類物件equlas父類物件就為false了，如下所示:

class GoodStudent extends Student {

    @Override
    public boolean equals(Object object) {
        return false;
    }

    public static void main(String[] args) {
        GoodStudent son = new GoodStudent();
        Student father = new Student();

        son.setName("test");
        father.setName("test");

		// 當使用instance of時
        System.out.println(son.equals(father)); // 這里為false
        System.out.println(father.equals(son)); // 這里為true

		// 當使用getClass()時
        System.out.println(son.equals(father)); // 這里為false
        System.out.println(father.equals(son)); // 這里為false	
    }
}

注意看這里用的是getClass()

回傳值兩個都是false，符合我們的預期，（連類都不一樣那肯定得為false啊）

而換成instanceof試試看咯：

運行結果：一個為true一個為false，很明顯出現問題了，

這里的原因如下：
instanceof的語法是這樣的：
當一個物件為一個類的實體時，結果才為true，但它還有一個特點就是，如果當這個物件時其子類的實體時，結果也會為true，這便導致了上述的bug，也就是說當比較的兩個物件，他們的類是父子關系時，instanceof可能會出現問題，**需要深究的小伙伴可以自己去了解一哈，所以在這里建議在實作重寫equals方法時，盡量使用getClass來實作，

在重寫equals方法的同時需要重寫hashCode方法，具體原因可能后續會講到~~