Passing null references

[Jason Keating]

Is anyone able to tell me what the rules are around passing null references to overloaded methods? I have look around but been unable to find any explanations.

Thanks in advance

Jason Keating

  public class Beta {
 
void m1(Object o){
System.out.println("In m1(Object o)");
}
void m1(String s){
System.out.println("In m1(String s)");
}
 
public static void main(String[] args) {
Beta beta = new Beta();
beta.m1(null);
}
 
}  
 
Output:In m1(String s)

[Edisandro Bessa]

Basically, when you have an overloaded method that receives a reference to an object, the JVM chooses the method whose signature contains the most specific object.

In your code example, the JVM chooses the second one one because String is more specific than Object.

It really works.

Try the following code :

class A {}
 
class B extends A{}
 
class C extends B{
    public void showMessage(Object o){
        System.out.println("Object call");
    }
 
    public void showMessage(A o){
        System.out.println("A call");
    }
 
    public void showMessage(B o){
        System.out.println("B call");
    }
 
    public void showMessage(C o){
        System.out.println("C call");
    }
 
    public static void main(String[] args){
        C myC = new C();
 
        [B]//It works as expected[/B]
        myC.showMessage(new A());
        myC.showMessage(new B());
        myC.showMessage(new C());
 
       [B]//JVM will choose the most specific one[/B]
       myC.showMessage(null);
 
       [B]// Surprise !!! What is the output ?[/B]
       A myA = new C();
       
       myC.showMessage(myA);
   }
}

Output is :

A call
B call
C call
C call
A call It was decided at compile time because you're explicitly passing an argument of type A, even though its reference is of type C

[Jason Keating]

Thanks thats a huge help

[Murali Mohan]

It was decided at compile time because you're explicitly passing an argument of type A, even though its reference is of type C

I think the reference variable is of type A but it refers to an object of type C.
Please Let me know if I am wrong.

[Yogesh Chhawasaria]

Adding Further to it
If there are more one method and there is more than one choice for a specific object... the compiler freaks out and wont let you compile the code

E.g.

   
public class Beta {
void m1(Object o){
System.out.println("In m1(Object o)");
}
 
void m1(String s){
System.out.println("In m1(String s)");
}
 
[B]void m1(StringBuffer s){
System.out.println("In m1(StringBufer s)");
}[/B] 
public static void main(String[] args) {
Beta beta = new Beta();
beta.m1(null);
}
}  
 

Error MSg :
Beta.java:16: reference to m1 is ambiguous, both method m1(java.lang.String) in
Beta and method m1(java.lang.StringBuffer) in Beta match
beta.m1(null);
[ February 23, 2006: Message edited by: Yogesh Chhawasaria ]

[swapnil paranjape]

"If there are more than one method and there is more than one choice for a specific object... the compiler freaks out and wont let you compile the code
"

yogesh can you please explain this in more detail....
i am confused because in overloaded methods we always have more than one method (referring above example of class A,B,C) and showMessage(Object o)
and showMessage(C o) there is more than one choice....
i think i am not clear with that...please explain....

can we say that the methos is called according to the type of refrence variable?

[Edisandro Bessa]

Hi swapnil,

Yogesh is correct. Im my above example, the code compiles just because all classes (A,B,C) are within the same inheritance tree. So, it's easy to compiler determine the most specific class.

However, when you have two specific classes belonging to differentes inheritance tree (as shown in Yogesh's example) the compiler complain.

Please take a look :

Object
  |
  |--> A
  |    |
  |    |-->B
  |        |
  |        |--> C [B] most specific in the inheritance tree[/B]
  |       
  |--> String
  |
  |--> StringBuffer
 
Here you can see that StringBuffer is not in the same inheritance tree as String, thus, the compiler is unable to determine which one is more specific.

Concerning to Murali's affirmation, it's the same as mine.

The argument is of type A but it refers to an instace object of type C.

[swapnil paranjape]

thanx a lot ...that was indeed great explanation.....really of great help.