In one of my interviews, an interviewer asked me:
Given a Student class and two objects s1 and s2:
s1 = new Student();
s2 = new Student();
How will s1 == s2 return true?
I told him to make Student class a singleton, but he said no, and that we have to make a change in the class level so that s1 == s2 would return true.
Note: we need to change Student class. Please don't reply s1=s2.
Any clue?
The operator == check if two objects are the same.
You created two different equals object.
So they are not the same and s1 == s2 will return false.
You have to redefine the method equals and check them with this method as follow:
s1.equals(s2)
The method equals:
Indicates whether some other object is "equal to" this one.
Note that when you redefine the method equals you need also to redefine the method hashCode, as explicitly documentated in the description of equals method:
Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.
Generally ide (like IntelliJ, Eclipse or Netbeans) helps you writing a good implementation of both methods.
Considering this I suppose that the interviewer has asked something like How will s1 equals s2 talking about it and you misunderstood it as How will s1 (simble equals) s2. Or he has explicitly written the operator == on the paper?
If the interviewer asked explicitly how to will
s1 == s2 // returns true
after creating the two objects as
Student s1 = new Student();
Student s2 = new Student();
The only possibility is to change the reference of s1 (or s2) as follow:
Student s1 = new Student();
Student s2 = new Student();
s1 = s2; // new added line , or the same if you write s2 == s1
s1 == s2 // now is true
But this is a trick, infact you are testing that two different variables are referencing the same object.
You can have a similar behaviour assigning to both variables null, or another Student previously created. Basically any change to code that assign to s1 the same reference of s2 will work.
This is kind of a trick, but will meet the requirements:
Change the Student constructor to throw some exception (I chose an unchecked exception, so I don't have to specify it in a throws clause):
public Student()
{
throw new NullPointerException();
}
Now, assuming we are allowed to add a try-catch block:
Student s1 = null;
Student s2 = null;
try {
s1 = new Student();
s2 = new Student();
}
catch (Exception e) {
}
System.out.println (s1==s2);
This will print true, since both s1 and s2 are null.
Even if we don't catch the exception, s1 == s2 will still be true after the two constructor calls (actually after the first constructor call, since the second one will never be executed), but we have to catch the exception somewhere in order to test it.
As already answered here, == compares the reference. ie it compares if s1 and s2 are pointing to the same object. Since you are using new to instantiate both s1 and s2, your requirement is just impossible.
The only logical solution I see are trivial:
s1 = new Student();
s2 = new Student();
s1=null;
s2=null;
System.out.println(s1==s2);
or:
s1 = new Student();
s2 = new Student();
s1=s2;
System.out.println(s1==s2);
or:
s1 = new Student();
s2 = new Student();
s2=s1;
System.out.println(s1==s2);
as @user7 suggested in the comment
== compares object references, it checks to see if the two operands point to the same object (not equivalent objects, the same object). So I really think that the only way can be something like this:
@Override
public Student clone(){
return this;
}
Maybe this will make the == operator work as you asked. This is horribly wrong to me because I don't think that this is the intended use of clone() method. Otherwise I do not have any other clues on how to make as you asked considering the constraint of working at class level.
If clone() cannot be used maybe the answer will be: it is not possible to do that.
As == operator compares objects references, I think that s1 and s2 has to be null.
