Is it a bad idea if equals(null) throws NullPointerException instead?

The contract of `equals` with regards to `null`, is as follows: For any non-null reference value `x`, `x.equals(null)` should `return false`. This is rather peculiar, because if `o1 != null` and `o2 == null`, then we have: ``` o1.equals(o2) // returns false o2.equals(o1) // throws NullPointerException ``` The fact that `o2.equals(o1) throws NullPointerException` is a good thing, because it alerts us of programmer error. And yet, that error would not be catched if for various reasons we just switched it around to `o1.equals(o2)`, which would just "silently fail" instead. So the questions are: - Why is it a good idea that `o1.equals(o2)` should `return false` instead of throwing `NullPointerException`? - Would it be a bad idea if wherever possible we rewrite the contract so that `anyObject.equals(null)` always throw `NullPointerException` instead? On comparison with `Comparable` In contrast, this is what the `Comparable` contract says: Note that `null` is not an instance of any class, and `e.compareTo(null)` should throw a `NullPointerException` even though `e.equals(null)` returns `false`. If `NullPointerException` is appropriate for `compareTo`, why isn't it for `equals`? Related questions - Comparable and Comparator contract with regards to null A purely semantical argument These are the actual words in the `Object.equals(Object obj)` documentation: Indicates whether some other object is "equal to" this one. And what is an object? JLS 4.3.1 Objects An object is a class instance or an array. The reference values (often just references) are pointers to these objects, and a special `null` reference, which refers to no object. My argument from this angle is really simple. - `equals` tests whether some other object is "equal to" `this` - `null` reference gives no other object for the test - Therefore, `equals(null)` should throw `NullPointerException`