Overriding the equals method that is inherited from Object

Question

I was given the task to override the equals method in java, and I would like to know if the two examples I have provided will accomplish the same thing. If so, what are the differences between them.

public class Animal {

    private int numLegs;

    public Animal(int legs) {
        numLegs = legs;
    }

    public boolean equals(Object other) {
        if(other == null) return false;
        if(getClass() != other.getClass()) return false;

        return this.numLegs == ((Animal)other).numLegs;
}

public class Animal {

    private int numLegs;

    public Animal(int legs) {
        numLegs = legs;
    }

    public boolean equals(Object other) {
        //check if other is null first
        if(other == null) return false;
        //Check if other is an instance of Animal or not 
        if(!(other instanceof Animal)) return false;
        //// typecast other to Animal so that we can compare data members
        Animal other = (Animal) other;
        return this.numLegs == other.numLegs;
    }

Check this https://stackoverflow.com/questions/4989818/instanceof-vs-getclass — Ivan Kaloyanov, Nov 27 '18 at 07:34
there's a compile error in the second example. You can't create `Animal other` in the `equals` method, since `other` is mentioned in the parameter `Object other`. — Roshana Pitigala, Nov 27 '18 at 07:36
Don't use != to compare objects (in the first example with getClass() != other.getClass()). — Ralf Renz, Nov 27 '18 at 07:36
@RalfRenz Would you mind sharing the reason for your suggestion? — ernest_k, Nov 27 '18 at 07:40
@ernest_k: look at https://stackoverflow.com/questions/7520432/what-is-the-difference-between-vs-equals-in-java — Ralf Renz, Nov 27 '18 at 08:35
@RalfRenz I thought you had a more specific reason. Normally `Class` objects are safe to compare with `==`. — ernest_k, Nov 27 '18 at 08:39

Eran · Answer 1 · 2018-11-27T07:40:47.167

They are not the same.

For the first implementation, you can only return true if both of the compared instances belong to the same class (for example, if both are Cat instances, assuming Cat extends Animal).

For the second implementation, you can compare a Cat to a Dog and still get true, since both are instances of Animal and have the same number of legs.

They will behave the same if there are no sub-classes of the Animal class, since in that case, if other instanceof Animal is true,getClass() == other.getClass()is alsotrue`.

P.S., the second snippet has a typo, since you are re-declaring the other variable:

Animal other = (Animal) other;
return this.numLegs == other.numLegs;

You probably meant to use a different variable name.

score 2 · Answer 2 · answered Nov 27 '18 at 07:36

2

They don't do the same thing with subclasses of Animal; say if you have a class Dog extending Animal, and an instance dog, calling animal.equals(dog) will return false with the first version, and true with the second.

answered Nov 27 '18 at 07:36

Maurice Perry

9,261
2
12
24

score 1 · Answer 3 · edited Nov 27 '18 at 07:47

1

They are different:

case 1: This check will always return true if the instance belongs to same class like Cow extends Animal and Cat extends Animal.

Case 2: In this case, if both are the instance of Animal and have same number of legs -- return true.

edited Nov 27 '18 at 07:47

ernest_k

44,416
5
53
99

answered Nov 27 '18 at 07:45

Sai prateek

11,842
9
51
66

Overriding the equals method that is inherited from Object

3 Answers3