Doubt in K&B 5: Which equals() method is better?

[Kaydell Leavitt]

I have a doubt about K&B 5.0 on page 526. The book says that you should use the instanceof method to determine whether the types are the same. I believe that it would be better to require that the classes be the same in order for the objects to be return true from the equals() method.

How should the equals() method be defined? Like equals1() or like equals2()?

   
package generics;
 
public class EqualsTest {
 
public static void main(String [] args) {
Moof moof1 = new Moof(8);
Moof moof2 = new Moofier(8);
if (moof1.equals(moof2)) {
System.out.println("equivalent");
} else {
System.out.println("NOT equivalent");
}
}

}

class Moof {

private int moofValue;

public Moof(int moofValue) {
this.moofValue = moofValue;
}

public boolean equals1(Object o) {
if (o == null) return false;
if (!(o instanceof Moof)) return false;
Moof other = (Moof) o;
return (this.moofValue == other.moofValue);
}

public boolean equals2(Object o) {
if (o == null) return false;
if (!(this.getClass() == o.getClass())) return false;
Moof other = (Moof) o;
return (this.moofValue == other.moofValue);
}

@Override
public boolean equals(Object o) {
// TODO which method should equals() call to be correct, equals1() or equals2()
return equals2(o);
}

}
 
class Moofier extends Moof {
 
public Moofier(int moofValue) {
super(moofValue);
}

}
 

[ September 11, 2008: Message edited by: Kaydell Leavitt ]

[Ankit Garg]

Well this can create a long debate. Just to say the least, instanceof must be used. It will help you to check for equality of objects of sub-classes of Moof class.

Read the following at your own risk
Actually it depends whether your class is final or not. If your class is not final then any overriding class will have to be careful while overriding the equals method. If it does something wrong, then the result will be that two calls to equals might not be symmetric(a contract of equals method).

Let's see it-

class Base
{
    int i;
    public boolean equals(Object other)
    {
        if (other == null) return false;
        if (!(other instanceof Base)) return false;
        return this.i == ((Base)other).i;
    }
}
class Derived
{
    int j;
    public boolean equals(Object other)
    {
        if (other == null) return false;
        if (!(other instanceof Derived)) return false;
        return super.equals(other) && (this.j == ((Derived)other).j);
    }
}

This code might look just fine but if you call it this way

Base baseObj = new Base();
baseObj.i = 10;
Derived derivedObj = new Derived();
derivedObj.i = 10;
derivedObj.j = 10;

in this case calling
baseObj.equals(derivedObj); //returns true

and calling
derivedObj.equals(baseObj); //returns false

So this breaks symmetric behaviour.

To solve this, you must either make equals final in Base. Otherwise both equals methods in Base and Derived must use getClass instead of instance of.

[Harshit Rastogi]

the only thing with instanceOf is that is a check if a
check is made for

 
Derived obj = new Derived();
(obj instanceof Base){
return true;}
   

will return true;

 public class MyModel {
 
private int age;
 
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
return result;
}
 
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final MyModel other = (MyModel) obj;
if (age != other.age)
return false;
return true;
}
}   

this is the automatic code generated when you write a code in Eclipse IDE and ask the IDE to override equals and hashcode method.

As you can see getClass() is used.
Also dont forget to implement hashcode().
In the end, finally its you call but i would say use getClass()
you can check the difference between instanceOf and getClass() at
Help link

[Kaydell Leavitt]

Here's what I think now.

1. I overrode the equals() method, so I needed to override the hashCode() method.
2. The test for == is an optimization for speed but is not necessary.
3. I don't want to assume that the class Moof is never going to be extended so it is safer to compare classes using the getClass() method than it is to use the instanceof operator.
4. I don't know how to use the instanceof() method, but I don't think that I need to use it here because my equals() method and my hashCode() method both obey their contracts.

The following code is my solution to my exercise. I would appreciate comments.

package generics;
 
public class EqualsTest {
 
public static void main(String [] args) {

// create two objects to test the method Moof.equals()
Moof moof1 = new Moof(8);
Moof moof2 = new Moof(8);
Moof moof3 = new Moofier(8);

// test that moof1 equals moof2
if (moof1.equals(moof2)) {
System.out.println("moof1.equals(moof2) is true");
} else {
System.out.println("moof1.equals(moof2) is false");
}

// test that moof1 != moof3
if (moof1.equals(moof3)) {
System.out.println("moof1.equals(moof3) is true");
} else {
System.out.println("moof1.equals(moof3) is false");
}

// test that null is not equal
if (moof1.equals(null)) {
System.out.println("does not handle null correctly");
} else {
System.out.println("handles null correctly");
}
 
// test for reflexitity
if (moof1.equals(moof1) && (moof2.equals(moof2))) {
System.out.println("is reflexive");
} else {
System.out.println("is NOT reflexive");
}

// test for symmetry
if (moof1.equals(moof2) == moof2.equals(moof1)) {
System.out.println("is symmetric");
} else {
System.out.println("is NOT symmetric");
}

}

}

class Moof {

private int moofValue;

public Moof(int moofValue) {
this.moofValue = moofValue;
}

@Override
public boolean equals(Object o) {
if (o == null) return false;// avoid NullPointerException
if (this == o) return true;// if this and o reference the same object then quickly return true
if (this.getClass() != o.getClass()) return false;// the class of both objects must be the same for them to be equals
Moof other = (Moof) o;// now, we know that o is a Moof so the type-cast is safe
return (this.moofValue == other.moofValue);// now, test the two objects to see if they are meaningfully equivalent.
}

@Override
public int hashCode() {
return moofValue;
}

}
 
class Moofier extends Moof {
 
public Moofier(int moofValue) {
super(moofValue);
}

}