Effective java讀書筆記 第八條

覆蓋equals方法其實是非常有講究的, 許多覆蓋方式會導致錯誤, 并且?guī)矸浅乐氐暮蠊? 首先看一下文檔上對equals方法是怎么說的吧

Object類的equals方法

自反性, 對稱性, 傳遞性, 有木有想起離散數(shù)學=-=

首先看一下哪些情況是不用覆蓋equals方法的, 這樣的話, 類的每個實例都只與它自己相等.

• 類的每個實例本質(zhì)上都是唯一的
  什么意思呢, 就是說這個類表示活動實體, 而不是值, 就不需要去覆蓋equals了, Object提供的實現(xiàn)就已經(jīng)足夠了. 比如說Thread, GUI的控件等等

• 不關心類是否提供邏輯相等的測試功能
  比如說java.util.Random覆蓋了equals, 用來檢查兩個Random實例產(chǎn)生的隨機數(shù)序列是否相同, 其實這并沒有什么卵用啊, Object對于equals的實現(xiàn)就夠啦

• 超類已經(jīng)覆蓋了equals, 對于子類也適用*
  這種情況無需再去實現(xiàn)equals

如果類具有自己特有的邏輯相等概念, 而超類的的equals并不是期望的實現(xiàn)的話, 就需要我們?nèi)ジ采wequals了.

需要覆蓋equals的時候就需要遵守上面截圖的規(guī)范啦:

• 自反性
  自反性說明一個對象是等于其自身, 自己和自己相等, Object的也就實現(xiàn)了這個了:

publicbooleanequals(Objectobj){
return(this==obj);
}

我就是我, 是顏色不一樣的煙火

• 對稱性
  簡單來說, 就是a=b成立的話, 那么b=a必定成立.
  來看個例子, 有一個CaseInsensitiveString類, 這個類比較的時候會忽略大小寫:

final class CaseInsensitiveString{
    private final String s;
    public CaseInsensitiveString(String s) throws NullPointerException{
        if (s == null) {
            throw new NullPointerException();
        }
        this.s = s;
    }

    @Override
    public boolean equals(Object o) {
        if(o instanceof CaseInsensitiveString) {
            return s.equalsIgnoreCase(((CaseInsensitiveString) o).s);
        } 
        if(o instanceof String) {
            return s.equalsIgnoreCase((String) o);
        }
        return false;
    }
}

覆蓋了equals, 判斷s與CaseInsensitiveString類的s或者和String忽略大小后是否相等, 否則就返回false, 然后我們來測試一下,

CaseInsensitiveString cis1 = new CaseInsensitiveString("boom!");
        CaseInsensitiveString cis2 = new CaseInsensitiveString("Boom!");
        String s = "BoOM!";
        System.out.println(cis1.equals(cis2));
        System.out.println(cis1.equals(s));
    }

輸出正如我們所料, 都是true, 但是別忘了自反性啊, cis1.equals(s)輸出true, s.equals(cis1)也應該是輸出true的, 事實上s.equals(cis1)的結果是false. 顯然違反了對稱性, String類的equals并不知道不區(qū)分大小寫的CaseInsensitiveString類, 因此s.equals(cis1)返回了false.
為了解決這個問題, 只要將企圖與String互操作的那段代碼從equals中刪除就行了

@Override
    public boolean equals(Object o) {
        return o instanceof CaseInsensitiveString && ((CaseInsensitiveString) o).s.equalsIgnoreCase(s);
    }

• 傳遞性
  最復雜的就是傳遞性了, 離散中最麻煩的也是求傳遞閉包了.
  傳遞性的意思也很簡單的, 就是a=b, b=c的話, 那么a和c也是相等的.
  
  
  有一個Point類, 用來表示坐標點

class Point{
    private final int x;
    private final int y;
    
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Point)) {
            return false;
        }
        Point p = (Point)o;
        return x == p.x && y == p.y;
    }
}

然后又有一個ColorPoint類, 來表示帶顏色的點

class ColorPoint extends Point {
    private final Color color;
    public ColorPoint(int x, int y, Color color) {
        super(x, y);
        this.color = color;
    }
}

沒有復寫equals的情況下, 雖然ColorPoint和Point作比較的時候能飯后正確的結果, 但是兩個ColorPoint之間做比較的時候忽略了顏色信息, 這顯然不是我們想要的結果, 于是乎:

@Override
    public boolean equals(Object o) {
        if (!(o instanceof ColorPoint)) {
            return false;
        }
        return super.equals(o) && ((ColorPoint) o).color == color;
    }
}

這樣對了嗎? 抱歉, 問題還是很大, 雖然實現(xiàn)了兩個有色點之間的比較, 但是當普通點和有色點比較的時候, 違反了對稱性, 普通點和有色點比較會忽略顏色, 而有色點和普通點則總是返回false.
繼續(xù)改:

@Override
    public boolean equals(Object o) {
        if (!(o instanceof Point)) {
            return false;
        }
        if(!(o instanceof ColorPoint)) {
            return o.equals(this);
        }
        return super.equals(o) && ((ColorPoint) o).color == color;
    }

如果o不是ColorPoint, 就用o去比較this, 這樣就會忽略顏色信息了, 測試一下:

        ColorPoint p1 = new ColorPoint(1, 1, Color.RED);
        Point p2 = new Point(1, 1);
        ColorPoint p3 = new ColorPoint(1, 1, Color.GREEN);
        System.out.println(p1.equals(p2));
        System.out.println(p2.equals(p3));

返回的都是true, 很好, 對稱性的問題解決了, 等等, 這里不是在討論傳遞性嗎!!!按照傳遞性來說, p1=p2, p2=p3, 所以p1和p3肯定是相等啊喂, 但是這里很明顯就是不相等的, 大家又不是色盲.
這樣寫呢

@Override
    public boolean equals(Object o) {
        if (o == null || o.getClass() != getClass()) {
            return false;
        }
        Point p = (Point)o;
        return x == p.x && y == p.y;
    }

只有當對象相同時才 比較, 這樣雖然解決了問題, 但是卻不是我們想要的解決方法, 來看一個更好的實現(xiàn), 用復合代替繼承:

class ColorPoint {
    private final Color color;
    private final Point point;
    public ColorPoint(int x, int y, Color color) {
        if (color == null) {
            throw new NullPointerException();
        }
        point = new Point(x, y);
        this.color = color;
    }

    public Point asPoint() {
        return point;
    }

    @Override
    public boolean equals(Object o) {
        if(!(o instanceof ColorPoint)) {
            return false;
        }
        ColorPoint cp = (ColorPoint) o;
        return cp.point.equals(point) && cp.color.equals(color);
    }
}

• 一致性
  如果兩個對象是相等的, 就應該保持一直是相等的, 除非這兩個對象中有一個或者兩個都被修改了, 所以記住: 相等的對象永遠相等, 不相等的對象永遠不相等.

• 非空性
  所有的對象都不能為null, 盡管很難想象什么情況下o.equals(null)會返回true. 但是意外拋出NullPointerException異常的可能卻不難想象, 所以可以這樣寫來不允許拋出NullPointerException異常

@Override
public boolean equals(Object o) {
    if (o == null) {
        return false;
    }
}