Question

According to Josh Bloch in Java:

There is no way to extend an instantiable class and add a value
component while preserving the equals contract, unless you are willing
to forgo the benefits of object-oriented abstraction

So here ‘s my case I had a class Foo that had overridden equals() and hashcode() as implemented by Intellij Idea . Now I have another class FooChild that extends Foo and adds a couple more fields to ‘Foo`. Now FindBugs is complaining about FooChild:

Class doesn’t override equals in superclass This class extends a class
that defines an equals method and adds fields, but doesn’t define an
equals method itself. Thus, equality on instances of this class will
ignore the identity of the subclass and the added fields. Be sure this
is what is intended, and that you don’t need to override the equals
method. Even if you don’t need to override the equals method, consider
overriding it anyway to document the fact that the equals method for
the subclass just return the result of invoking super.equals(o).

My question is “What is meant by equality on instances of this class will
ignore the identity of the subclass ? I understand the part about ignoring the added fields since no equals() method has been written for them yet .

Answer 1

What is meant by “equality on instances of this class will ignore the
identity of the subclass ?”

If class Foo has an equals() method, then FooChild inherits it, meaning that if you compare two instances of FooChild using equals(), the Foo.equals() method will be called.

If FooChild has any data members, then it’s probably possible for two instances of FooChild to have the same values for members in their Foo parts, but different values for the members defined directly in the class. But the Foo.equals() method will only look at the members defined in Foo, and so would pronounce two such objects to be equals(), even though their FooChild parts are different.

This is why you need to override equals() in FooChild.

Now, what happens if you compare a Foo and a FooChild using equals(), when both classes have their own version of equals()? It depends which object you call equals() on, and it depends on how you implement the two equals() methods. Frankly, it’s a mess! That’s the meaning of the first quote, the one from Josh Bloch. It’s impossible to define these two equals() methods so they always do the right thing. Therefore, it’s best to avoid the situation where one value class (i.e., a class whose identity is tied up with the values of its member variables) extends another value class.