why this outout

[Sireesha Mullapudi]

Hi,

Why the following code is not giving compile time error

public class Test2{
    static void method(Object obj){
        System.out.println("Object");
    }
    static void method(String str){
        System.out.println("String");
    }
    public static void main(String args[]){
        method(null);
    }
}    

Thanks
scjp1.4

[Joe San]

Hi Lakshmi,

Why do you think that it should give a compile time error?? The method method(null) matches the string version and prints string as o/p. If you remove the static method that takes String as argument, it prints object as the O/P. It's a good question. Can anyone please explain this behaviour.

Regards,
Jothi Shankar Kumar. S

[anvesh charuvaka]

Hi

The null Literal can be cast into any type of Object Reference.
So any one of the given method()'s can be called but the compiler tries to choose the most specific one.

Now the null matches the call for method(Object )
then it also matches the call for method(String )

since the string version is more specific the call is made to the method(String ) version.

But if you overload the method with Integer
metod(Integer ) then the complier does not know which one to call because
The String version is as specific as Integer version so the compiler shouts that the call is "AMBIGUOUS"

[Paul Anilprem]

I can almost hear someone say, "how do you know X is more specific than Y?"

Simple answer is, if X extends Y directly or indirectly, X is more specfic than Y. If there is no direct or indirect inheritance relationship between X and Y, both are equally specific.

So Integer is more specific than Number and Number is more specific than Object. But String and Integer(or Number) are equally specific.

[Burkhard Hassel]

Hi all,


this ambiguity can be seen for interfaces as well:

interface Inter1{}
interface Inter2{}
class A implements Inter1, Inter2{}
 
public class Main {
public static void main(String[] args) {
A a = new A();
foo(a);
}
 
// for A's
static void foo(A a) {
System.out.println("class A");
}
 
static void foo(Inter1 face) {
System.out.println("Interface one");
}
 
static void foo(Inter2 face) {
System.out.println("Interface two");
}
}

This code produces:
class A


but if you delete the method // for A's
it is ambigous and the line foo(a); in main cannot compile.
Same would be true for foo(null);




Yours,
Bu.