Java code related to equals method

Question

I am practicing for an exam, and found a sample problem that I don't understand.

For the following code, find what the output is:

public class Test {

    private static int count = 0;

    public boolean equals(Test testje) {
        System.out.println("count = " + count);
        return false;
    }

    public static void main(String [] args) {
        Object t1 = new Test();
        Object t2 = new Test();
        Test t3 = new Test();
        Object o1 = new Object();

        ++count; t1.equals(t2);
        ++count; t1.equals(t3);
        ++count; t3.equals(o1);
        ++count; t3.equals(t3);
        ++count; t3.equals(t2);
    }
}

The output of this code is count = 4, but I don't understand why. Can anyone help me?

The correct answer to "what does code like this do" should be "gets the too-clever programmer fired." — fluffy, Jan 15 '16 at 21:59
I'm not horribly familiar with modern Java, could you point out the cleverness @fluffy ? — Daniel, Jan 16 '16 at 02:15
@Daniel see eran's answer - it has vastly different behaviors based on the call-site type of the method parameter, thanks to a purposefully confusing method overload. — fluffy, Jan 16 '16 at 05:17
I'll also note that using dutch variable names in code is heavily frowned upon. — Elva, Jan 16 '16 at 11:42
See http://meta.stackoverflow.com/questions/253894/how-to-handle-explain-how-this-code-dump-works-questions — Raedwald, Jan 16 '16 at 11:51
I wish that Java equals exercise! Then I wouldn't need to go to the gym. ;) — Chad Schultz, Jan 17 '16 at 01:00
You should learn to use the debugger, would take 10 secs to find out whats going on — wutzebaer, Jan 20 '16 at 08:33
Teachers that come up with cute exam questions like this should be fired. — wvdz, Jan 23 '16 at 11:28

Eran · Accepted Answer · 2016-01-15T15:08:50.583

The first thing you should note is that public boolean equals(Test testje) doesn't override Object's equals, since the argument is Test instead of Object, so the signatures don't match.

Therefore the main method calls equals(Test testje) exactly once - when executing t3.equals(t3); - since that's the only case in which both the static type of the instance equals is executed for and the type of the argument are the Test class.

t3.equals(t3); is the 4th equals statement (which comes after 4 increments of the static count variable), so 4 is printed.

All the other equals statements execute Object's equals, and therefore print nothing.

A more detailed explanation :

t1.equals() calls Object's equals regardless of the type of the argument, since the static (compile time) type of t1 is Object, and the Test class doesn't override that method. The Object class doesn't have an equals method with a single Test argument, so equals(Test testje) can't be called, regardless of the dynamic (runtime type) of t1.

t3.equals() can execute either Object's equals or Test's equals, since the compile time type of t3 is Test, and the Test class has two equals methods (one inherited from the Object class and the other defined in the Test class).

The method being chosen depends on the compile time type of the argument : 1. When the argument is Object (as in t3.equals(o1); or t3.equals(t2);), Object's equals is called and nothing is printed. 2. When the argument is Test, as in t3.equals(t3);, both versions of equals match that argument, but due to the rules of method overloading, the method with the most specific argument - equals(Test testje) - is chosen and the count variable is printed.

Geeeez, that's why I use the @Override annotation – Pierre Arlaud Jan 16 '16 at 12:57 — Pierre Arlaud, Jan 16 '16 at 12:57

score 11 · Answer 2 · answered Jan 15 '16 at 14:53

The equals method in Test takes an instance of Test.

All the previous attempts have been made with an instance of Object, which take the inherrited method from the Object class:

public boolean equals(Object o){
  return this == o;
}

Since there is no print in there, it won't print any value.

Your ++count; will increment the value of count, so the moment when you actually call your

public boolean equals(Test testje){...

method, that does print that value, the value of count is 4.

score 7 · Answer 3 · edited Jan 22 '16 at 20:20

t3.equals(t3) is the only line which has the right arguments that match the method signature public boolean equals (Test testje) so it's the only line in the program which actually calls that print statement. This question is designed to teach you a few things.

All class implicitly extend Object
Object.java contains an equals method which takes type Object
multiple methods with the same name can exist provided they have different arguments - this is known as method overloading
the method method overload who's signature matches the arguments at runtime is the method that gets invoked.

Essentially the trick here is that Test implicitly extends Object like all java classes do. Object contains an equals method that takes type Object. t1 and t2 are typed such that at run time the arguments never match the method signature of equals that is defined in Test. Instead it's always calling into the equals method in Object.java because either the base type Is Object in which case the only methods you have access to are the ones defined in Object.java or the derived type is Object in which case

public boolean equals(Test testje)

Cannot be entered because in that case at runtime the argument is of type Object which is a Superclass of Test, not a subclass. So instead it looks at the equals method in the Test.java's implicitly typed superclass Object.java which also contains an equals method, which just happens to have a method signature of

public boolean equals (Object o)

which in this case match our arguments at runtime so this equals method is the one that executes.

Notice in the case of t3.equals(t3) both the base type and the derived type of t3 are Test.

Test t3 = new Test ();

this means that at runtime you are calling the equals method in Test.java and the argument you are passing in is actually of type Test so the method signatures match and the code inside Test.java executes. At this point count == 4.

Bonus bit of knowledge for you:

@Override

annotation you may have seen in a few places explicitly instructs the compiler to fail if it does not find method with the exact same signature somewhere in a Superclass. This is useful to know if you definitely intend to override a method and you want to be absolutely sure that you really are overriding the method and you haven't accidentally changed the method in either the superclass or subclass but not both and Introduced a runtime error where the wrong implementation of the method is being called causing unwanted behavior.

score 4 · Answer 4 · edited May 23 '17 at 12:26

4

There's two key things that you should know.

Overridden methods must have the exact signatures as their superclass have. (in your example this condition doesn't meet.)
In Java for an object, we have two types: compile type and runtime type. In the following example compile type of myobj is Object but its runtime type is Car.
```
public class Car{
      @Override
      public boolean equals(Object o){
            System.out.println("something");
            return false;
      }
}
```
Object myobj = new Car();

Also you should note that myobj.equals(...) results in printing something in the console.

edited May 23 '17 at 12:26

Community

1
1

answered Jan 15 '16 at 18:48

frogatto

28,539
11
83
129

1

@Override is not needed, heck it didn't exist at all until 1.5 – plugwash Jan 15 '16 at 22:38
@plugwash is right. You don't need @Override. In fact in this case if you add @Override the code will likely stop compiling because there is no `equals` method in the superclass with the same method signature. @Override annotation is to tell the compiler 'there should be something in a superclass with this exact method signature - please complain if there is not as this method is intended to actually override something on purpose' – james_s_tayler Jan 16 '16 at 01:19
Yep that is why you use @Override. So when you intended to override something but screwed up the details the compiler screams at you rather than silently overloading instead. – plugwash Jan 17 '16 at 00:21
@plugwash Thank you for the hint. – frogatto Jan 17 '16 at 08:18

Java code related to equals method

4 Answers4