Calling overloaded methods with null

[Thomas Hauck]

1. When you pass the overloaded methods a hardcoded String on line 3

tc.method("Test"); // line 3

the "String Version"
will be selected.

The compiler is able to distinguish between String and StringBuffer on line 3.

Both String and StringBuffer reference variables 'sb1' and 's1' can be assigned 'null'.

public class TestClass {
	public void method(Object o) {
		System.out.println("Object Version");
	}

	public void method(String s) {
		System.out.println("String Version");
	}

	public void method(StringBuffer s) {
		System.out.println("StringBuffer Version");
	}

	public static void main(String args[]) {
		TestClass tc = new TestClass();	              // line 1
		StringBuffer sb1 =new StringBuffer("Test");  // line 2
		String s1 =  new String("Test");
		tc.method("Test");                 // line 3
        tc.method(null);                    // line 4 // The method method(Object) is ambiguous for the type TestClass
	}
}

If on line 4 you attempt
tc.method(null);

you will receive a compiler error.

Question:
Is this because the compiler will not know which method
to select if you attempt to call 2 overloaded methods with null?

[Heena Agarwal]

Thomas Hauck wrote:1. When you pass the overloaded methods a hardcoded String on line 3

tc.method("Test"); // line 3

the "String Version"
will be selected.

The compiler is able to distinguish between String and StringBuffer on line 3.

I hope you know that "Test" is certainly a String. It is not a StringBuffer. So the compiler has no reason for getting confused here.

Thomas Hauck wrote:
Both String and StringBuffer reference variables 'sb1' and 's1' can be assigned 'null'.

public class TestClass {
	public void method(Object o) {
		System.out.println("Object Version");
	}

	public void method(String s) {
		System.out.println("String Version");
	}

	public void method(StringBuffer s) {
		System.out.println("StringBuffer Version");
	}

	public static void main(String args[]) {
		TestClass tc = new TestClass();	              // line 1
		StringBuffer sb1 =new StringBuffer("Test");  // line 2
		String s1 =  new String("Test");
		tc.method("Test");                 // line 3
        tc.method(null);                    // line 4 // The method method(Object) is ambiguous for the type TestClass
	}
}

If on line 4 you attempt
tc.method(null);

you will receive a compiler error.

Question:
Is this because the compiler will not know which method
to select if you attempt to call 2 overloaded methods with null?

Right. Because a null gives no data to the compiler about its intended reference type.
So if you have two or more overloaded methods that have a reference variable as a parameter and you invoke one of these overloaded methods by passing null as an argument, you will get a compile time error.

[Roel De Nijs]

And to add a little bit more. These will all compile and it's up to you to decide what will be printed

Integer i2 = null;
StringBuffer sb2 = null;
String s2 = null;
tc.method(i2);
tc.method(sb2);
tc.method(s2);
tc.method(10);
tc.method((Boolean)null);
tc.method((String)null);
tc.method((StringBuffer)null);

[Prathima gaitonde]

Great reply @Roel.

First of all I dint know null can be casted. Secondly this program can take everything as a parameter except null value. Here primitives are upgraded as object and it calls method which takes object as a parameter, when argument is primitive!!!

Thanks & regards,
Prathima

[Sibendu Dey]

Thomas Hauck wrote:1. When you pass the overloaded methods a hardcoded String on line 3

tc.method("Test"); // line 3

the "String Version"
will be selected.

The compiler is able to distinguish between String and StringBuffer on line 3.

Both String and StringBuffer reference variables 'sb1' and 's1' can be assigned 'null'.

Here "Test" is a String , hence , it is quite straight forward that the compiler will call the method with String as parameter.

Thomas Hauck wrote:

public class TestClass {
	public void method(Object o) {
		System.out.println("Object Version");
	}

	public void method(String s) {
		System.out.println("String Version");
	}

	public void method(StringBuffer s) {
		System.out.println("StringBuffer Version");
	}

	public static void main(String args[]) {
		TestClass tc = new TestClass();	              // line 1
		StringBuffer sb1 =new StringBuffer("Test");  // line 2
		String s1 =  new String("Test");
		tc.method("Test");                 // line 3
        tc.method(null);                    // line 4 // The method method(Object) is ambiguous for the type TestClass
	}
}

If on line 4 you attempt
tc.method(null);

you will receive a compiler error.

Question:
Is this because the compiler will not know which method
to select if you attempt to call 2 overloaded methods with null?

If you call the method with null as argument , then both the methods with String and StringBuffer as arguments become eligible to handle the call.
The compiler doesn't find any "specific" method to be called.

Consider the following code

class A {


}

class B {



}


class C extends A{

public static void X(C c){

}

public static void X(A a){


}

public static void Y(B b){


}

public static void Y(A a){

}

public static void main(){
X(null);  // Compilation succeeds because X(C c) is more specific in handling the call in comparison to X(A a) since C is a subclass of A 
Y(null); // Compilation fails because Y(B b) and Y(A a) both of them are eligible to handle the call , compiler loses his mind over which method to choose ;)
}


}

Hope it helps!!