繼承 - 在子類中使用super.equals（）覆蓋在超類的equals方法中使用的方法

Question

我一直在測試一個代碼並偶然發現一個問題：你應該在子類中調用super.equals()方法，該方法可以覆蓋一些用於equals()超類的方法？

讓我們看看下面的代碼：

public abstract class Item { 
    private int id; 
    private float price; 

    public Item(int id, String name, float price, String category) { 
     this.id = id; 
     this.name = name; 
     this.price = price; 
     this.category = category; 
    } 

    public int getID() { 
     return id; 
    } 

    public float getPrice() { 
     return price; 
    } 

    @Override 
    public boolean equals(Object object){ 
     if(object instanceof Item){ 
      Item item = (Item) object; 
      if(id == item.getID() 
       && price == item.getPrice())      
      { return true; } 
     } 
     return false; 
    } 
} 

類和子類DiscountedItem：

public class DiscountedItem extends Item { 
    // discount stored in % 
    private int discount; 

    @Override 
    public boolean equals(Object object) { 
     if(object instanceof DiscountedItem){ 
      DiscountedItem item = (DiscountedItem) object; 
      return (super.equals(item) 
        && discount == item.getDiscount() 
      ); 
     } 
     return false; 
    } 

    public int getDiscount() { 
     return discount; 
    } 

    @Override 
    public float getPrice() { 
     return super.getPrice()*(100 - discount); 
    }  
} 

我一直在剛剛重新閱讀Angelika Langer's secrets of equals()，她甚至說：

如果類有一個超類Object以外的類，應該調用super.equals（）。

但我認爲當子類重寫某些方法時，這是非常不可預測的。例如，當我使用equals比較2個DiscountedItem對象，超級方法被調用，item.getPrice()動態分派到正確的方法在子類中DiscountedItem，而其他價格值是使用變量直接訪問。

那麼，它是真的取決於我（因爲我應該正確實施該方法）還是有辦法解決它嗎？

Answer 1

比較實例變量，而不是直接的實例變量與它相關的getter方法。

例如，更改

&& price == item.getPrice()) 

到

&& this.price == item.price) 

該吸氣劑的方法是不必要的，因爲私有實例變量僅類結構外部訪問。

---

注：

我以前提出以下建議：

&& this.getPrice() == item.getPrice()) 

儘管它會在問題的例子工作，它不適合於所有情況。試想，如果子類DiscountedItem聲明的方法getPrice這樣：

@Override 
public float getPrice() { 
    return Math.floor(super.getPrice()); 
} 

這會導致錯誤的等價：

DiscountedItem firstItem = DiscountedItem(1, "", 1.1, ""); 
DiscountedItem secondItem = DiscountedItem(1, "", 1.0, ""); 
firstItem.equals(secondItem); // Returns true despite different prices. 

Answer 2

哦，我，我想我不得不發佈問題得到它。

爲了擺脫問題，不要直接訪問變量 - 調用getters！

@Override 
public boolean equals(Object object){ 
     if(object instanceof Item){ 
      Item item = (Item) object; 
      if(this.getID() == item.getID() 
       && this.getPrice() == item.getPrice())      
      { return true; } 
     } 
     return false; 
} 

此代碼在覆蓋方法時不再存在問題。

Answer 3

如果您在遇到問題時調用DiscountedItem的等號？ 如果有東西是DiscountedItem和其他東西是這兩個 永遠不會等於等於。對？所以如果你總是打電話給獲得者，我不會看到任何問題。

此外，如果您覆蓋equals，則需要重寫hashCode。

Answer 4

equals的執行應取決於狀態和類型，但不取決於功能。你在你的基類出了問題：

@Override 
public boolean equals(Object object){ 
    if(object instanceof Item){ // Type check- good! 
     Item item = (Item) object; 
     if(id == item.getID() // Depends on functionality- bad! 
      && price == item.getPrice()) // Depends on functionality- bad!      
     { return true; } 
    } 
    return false; 
} 

item.getID()和item.getPrice()，因爲你已經注意到，可以覆蓋打破Item.equals()合同。

@Override 
public boolean equals(Object object){ 
    if(object instanceof Item){ // Type check- good! 
     Item item = (Item) object; 
     if(id == item.id // Depends on state- good! 
      && price == item.price) // Depends on state- good! 
     { return true; } 
    } 
    return false; 
} 

這將永遠不會被子類破壞。此外，它可以讓孩子有意義地委託給它。

@Override 
public boolean equals(Object object) { 
    if(object instanceof DiscountedItem){ 
     DiscountedItem item = (DiscountedItem) object; 
     return (super.equals(item) 
       && this.discount == item.discount 
     ); 
    } 
    return false; 
} 

孩子只需要擔心比較它擁有的數據。