Question: When running FindBugs on my project, I got a few instances of the error described above.

Namely, my overriding versions of equals cast the RHS object into the same type as the object in which the overriding version is defined.

However, I'm not sure whether a better design is possible, since AFAIK Java does not allow variance in method parameters, so it is not possible to define any other type for the equals parameter.

Am I doing something very wrong, or is FindBugs too eager? 

A different way to phrase this question is: what is the correct behavior if the object passed to equals is not the same type as an LHS: Is this a false, or should there be an exception?

For example:

```
public boolean equals(Object rhs)
{
    MyType rhsMyType = (MyType)rhs; // Should throw exception
    if(this.field1().equals(rhsMyType.field1())... // Or whatever
}

```

Answer: 
Typically, when implementing equals you can check to see whether the class of the argument is equal (or compatible) to the implementing class before casting it. Something like this:

```
if (getClass() != obj.getClass())
    return false;
MyObj myObj = (MyObj) obj;

```

Doing it this way will prevent the FindBugs warning.

A side note to address a comment:  

Some people argue to use `instanceof` instead of `getClass` to check type safety. There is a big debate on that, which I was trying not to get into when I noted that you can check for class equality **or** compatibility, but I guess I can't escape it. It boils down to this - if you use `instanceof` you can support equality between instances of a class and instances of its subclass, but you risk breaking the symmetric contract of `equals`. Generally I would recommend not to use `instanceof` unless you know you need it and you know what you are doing. For more information see:

* <http://www.artima.com/weblogs/viewpost.jsp?thread=4744>
* [What issues should be considered when overriding equals and hashCode in Java?](https://stackoverflow.com/questions/27581/overriding-equals-and-hashcode-in-java)
* <http://www.macchiato.com/columns/Durable5.html>
* <http://commons.apache.org/lang/api-release/org/apache/commons/lang/builder/EqualsBuilder.html> (Apache common's implementation helper)
* <http://www.eclipsezone.com/eclipse/forums/t92613.rhtml> (Eclipse's default equals generator)
* NetBeans generator also uses getClass()
I start my equals(Object) implementations like this:

```
if ((object == null) || !(object instaceof ThisClass)) {
    return false;
}

```

This will also prevent the FindBugs warning but will not automatically return `false` when a subclass of ThisClass is being handed in. It might also be considered equal, especially if its `equals(Object)` method hasn’t been overridden.