Which of the following are correct regarding an equals() method in java?

This is a question on one of my practice exams that has me stumped.

Potential Answers

1. An equals() method written in a class named C must have a parameter that is declared to be of type C, in order to override the equals() method in the Object class.

2. An equals() method must have a parameter that is declared to be of type Object, in order to override the equals() method in the Object class.

3. An equals() method written in a class named C must cast its parameter to Object, even if its parameter is declared to be of type C, otherwise it will not be able to properly compare the fields of current object to those of the parameter object.

4. A well-designed equals() method should check for and handle the case where its current object may be null

5. An equals() method in a subclass cannot refer directly to private fields in a superclass in order to compare them, so it should invoke the superclass equals() method to do this

The answer is #2 & #5. I don't understand why #1 is wrong and #2 is correct. Don't you have to compare one type C with another type C? And why is #5 correct. I don't understand this one at all. Can't subclasses access the private fields of a superclass?

> I don't understand why #1 is wrong

Because:

1. Object::equals is defined as public boolean equals(Object), and

2. public boolean equals(SomeType) does not override public boolean equals(Object). This is actually an overload not an override. They are different operations.

> Can't subclasses access the private fields of a superclass?

In general, no they can't. Check your lecture notes.

There are some exceptions that involve the subclass being declared inside the superclass.

Technically, answer #5 is only half right.

• It is correct that the subclass cannot access private fields in the superclass, assuming we stay within the bounds of pure Java. The Java access rules forbid this. (But see above.)

• It is correct that calling super.equals(other) could be a solution. And indeed, it usually is the correct solution.

• It is incorrect to imply that calling super.equals(other) is the only solution.

Other possible solutions may include:

• ignoring the superclass fields when testing for equality,
• accessing the private fields of the superclass using public getters ... if they exist, or
• accessing the private fields by abstraction-breaking reflection.

Of the alternatives, the first one is rarely applicable and the third is a really bad idea. But these alternatives mean that Answer #5 (as written) is technically incorrect.

If this is your practical exam: did your course material not cover this?

As for #1: the method signature is public boolean equals(Object obj), so that's what you have to override. Any other signature and it's not an override, it's "a completely different method".

As for #5: That's what private means. The fields are private to that class and only that class. If a subclass should have access to them, then they'd have to be protected, not private.

Consider the following equals method for C class.

 @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        C c= (C) o;
        return id == c.id;
    }

Explanation for 1 & 5 options:

1. If you declare the parameter of type C, then it will not be overriding.

   Error:

> Method does not override method from its superclass

> Indicates that a method declaration is intended to override a method declaration in a supertype. If a method is annotated with this annotation type compilers are required to generate an error message unless at least one of the following conditions hold:
The method does override or implement a method declared in a supertype.
The method has a signature that is override-equivalent to that of any public method declared in Object.

5. superclass cannot access private fields of a class, so they need to call the superclass equals method to compare them.