在Java中为我的对象实现Equals和hashCode

Question

So I know this is widely talked about and discussed and I'm just trying to get my equality working for Shapes. I have created a class Shape that says what type of Shape, (ie rect,triangle,circle) and I'm trying to return true if they are of the same shape.

In main for testing...

Rectangle myRect = new Rectangle(3,5);
Rectangle myRect2 = new Rectangle(3,5);
  if (myRect==myRect2){              
            System.out.println("Both the objects are equal");   
        }          
        else {   
            System.out.println("Both the objects are not equal");  
        } 

and my actual Shape class with overriding equals and hashcode.

abstract class Shape
{ 
abstract double area(); 

  public Shape getShape(){
    return shape;
  }

@Override
    public boolean equals(Object other) {
    if (other == this) return true;
    if (other == null) return false;
    if (getClass() != other.getClass()) return false;
    Shape shape = (Shape)other;
   return(other==this);
  }

    @Override
    public int hashCode() {
        return shape.hashCode();
    }

Basically I keep getting false as my output, any insight would be helpful, thanks!

Answer 1

myRect==myRect2 returns true only if they are the same objects. You should use myRect.equals(myRect2);

Answer 2

In java, when it comes to objects, using == means checking the address value of object. Let me explain this with an example:

Rectangle objA = new Rectangle(3,5);
Rectangle objB = objA;

Here objA is created on memory location A and objB points to memory location A , or where objA was created. This means that both memory locations are the same, meaning that objA == objB will return true.

But in another case:

Rectangle objC = new Rectangle(3,5);
Rectangle objD = new Rectangle(3,5);

You might say, oh they both have the same width and height the same, they must be same objects. But see, that's not the case, because objC was created on memory location C and objD was created on memory location D , because they were each created with separate new (constructor) call. Memory locations in this case is different, meaning that objC == objD will return false.

Memory locations aren't named like that, I just used this to easier describe my examples.

---

You were thinking right when you wanted to use .equals method, that's what java is using to compare two objects deeper than just their address. But in custom classes, it's up to user to define how this method works, when two objects are equal and when not.

But your .equals implementation is a bit faulty.

This line checks if object other is pointing to memory location of this .

if (other == this) return true;

But later, you have these 2 lines:

Shape shape = (Shape)other;
return(other==this);

You don't do anything with the shape object, so why even create it, it's just making more work for garbage collector. And return other==this is a bit redundant, because if earlier line returns true, only possibility here is to return false, so this check is just more complex version of return false .

---

When you're using abstract classes that are later extended by other derived classes, you should implement .equals method in each of those classes. Example from your case, you'll probably want to compare two rectangles differently than two circles, right?

Rather than using one general .equals method, which, frankly, is not any better than using just the == operator, you should implement it for each of derived classes.

I don't know how exactly your Rectangle class looks like, but I'll give it a try:

public boolean equals(Object other) {
    if (other == this) return true;
    if (other == null) return false;
    if (getClass() != other.getClass()) return false;
    Rectangle rect = (Rectangle) other;
    // compare measures of this and other Rectangle
    return width == rect.width && height == rect.height;
}