Why should I not use equals with inheritance?
Because it's hard (impossible?) to make it right, especially the symmetric property.
Say you have class
Vehicle and class
Car extends Vehicle.
true if the argument is also a
Vehicle and has the same weight. If you want to implement
Car.equals() it should yield
true only if the argument is also a car, and except weight, it should also compare make, engine, etc.
Now imagine the following code:
Vehicle tank = new Vehicle(); Vehicle bus = new Car(); tank.equals(bus); //can be true bus.equals(tank); //false
The first comparison might yield
true if by coincidence tank and bus have the same weight. But since tank is not a car, comparing it to a car will always yield
You have few work-arounds:
strict: two objects are equal if and only if they have exactly the same type (and all properties are equal). This is bad, e.g. when you subclass barely to add some behaviour or decorate the original class. Some frameworks are subclassing your classes as well without you noticing (Hibernate, Spring AOP with CGLIB proxies...)
loose: two objects are equal if their types are "compatible" and they have same contents (semantically). E.g. two sets are equal if they contain the same elements, it doesn't matter that one is
HashSetand the other is
TreeSet(thanks @veer for pointing that out).
This can be misleading. Take two
LinkedHashSets (where insertion order matters as part of the contract). However since
equals()only takes raw
Setcontract into account, the comparison yields
trueeven for obviously different objects:
Set<Integer> s1 = new LinkedHashSet<Integer>(Arrays.asList(1, 2, 3)); Set<Integer> s2 = new LinkedHashSet<Integer>(Arrays.asList(3, 2, 1)); System.out.println(s1.equals(s2));
Martin Odersky (the guy behind generics in Java and the original codebase for the current
javac) has a nice chapter in his book Programming in Scala addressing this problem. He suggests that adding a
canEqual method can fix the equality/inheritance problem. You can read the discussion in the first edition of his book, which is available online:
The book is of course referring to Scala, but the same ideas apply to classic Java. The sample source code shouldn't be too difficult for someone coming from a Java background to understand.
It looks like Odersky published an article on the same concept in Java back in 2009, and it's available on the same website:
How to Write an Equality Method in Java
I really don't think trying to summarize the article in this answer would do it justice. It covers the topic of object equality in depth, from common mistakes made in equality implementations to a full discussion of Java
equals as an equivalence relation. You should really just read it.