Let's start with looking at a code-segment and try to think of the output/error, it would produce when compiled/executed and subsequently we'll discuss the behavior of code.
public class NullTest {
public static void method(Object obj){
System.out.println("method with param type - Object");
}
public static void method(String obj){
System.out.println("method with param type - String");
}
public static void main(String [] args){
method(null);
}
}
So, what do you expect as the output here? Before thinking about the output, do you really expect the code to compile successfully? Well... yeah, the code will compile and run fine as opposed to anyone who might have sensed an ambiguity here - we'll see the reason soon.
Since the methods are overloaded, the resolution will be done at compile-time only. Which method do you see being bind here - the one with parameter type 'Object' or the one with parameter type 'String' and why? Of course, the compiler can't bind two methods with one call, so on what basis would it pick the most suitable? Which method would be picked, is evident from the output given below:-
method with param type - StringAny guesses for why a special treatment is being given to 'String' here? Well... it's not actually for 'String' class specifically, but any sub-class would get a preference over the super class in such a situation. But, why? Because JLS (Section: 15.12.2.5) allows this. It clearly says:
"If more than one member method is both accessible and applicable to a method invocation, it is necessary to choose one to provide the descriptor for the run-time method dispatch. The Java programming language uses the rule that the most specific method is chosen."
As you easily deduce that the compiler should be able to pick 'the most specific', failing which it will throw a compile-time error. Let's understand it with the below code-segment which doesn't compile because the compiler can't pick 'the most specific' here.
public class NullTest {
public static void method(Object obj){
System.out.println("method with param type - Object");
}
public static void method(String str){
System.out.println("method with param type - String");
}
public static void method(StringBuffer strBuf){
System.out.println("method with param type - StringBuffer");
}
public static void main(String [] args){
method(null); //... compile-time error!
}
}
Why is the compiler not able to pick 'the most specific' here - because both String and StringBuffer are are sub-classes of the Object class, but without being in the same inheritance hierarchy. For finding 'the most specific' method, the compiler needs to find a method having the parameter type, which is
a sub-class of the parameter types of all other overloaded methods.
This holds true for overloaded methods
having more than one parameters as well. The compiler would pick 'the most specific' by looking which method is having at least one of its parameter types as a clear sub-class of the corresponding parameter type and other parameter types being either the same or clear sub-classes, in all other overloaded methods. If it can find one, good, otherwise it will throw a compile-time error. For example:
public class NullTest {
public static void method(Object obj, Object obj1){
System.out.println("method with param types - Object, Object");
}
public static void method(String str, Object obj){
System.out.println("method with param types - String, Object");
}
public static void main(String [] args){
method(null, null);
}
}
Outputmethod with param types - String, Object
In this case the compiler can easily pick 'the most specific' as the method having parameter types (String, Object) as the other overloaded method is having its parameter types as (Object, Object) - clearly 'String' is a subclass of 'Object' and the other parameter is of same type, so the method with parameter types (String, Object) can be picked with ease. But, the below code would throw a compile-time error as none of the methods satisfy the condition for being picked as 'the most specific' method.
public class NullTest {
public static void method(Object obj, String obj1){
System.out.println("method with param types - Object, String");
}
public static void method(String str, Object str1){
System.out.println("method with param types - String, Object");
}
public static void main(String [] args){
method(null, null); //... compile-time error!
}
}
