'Method Overloading for null argument

I have added three methods with parameters:

public static  void doSomething(Object obj) {
    System.out.println("Object called");
}

public static  void doSomething(char[] obj) {
    System.out.println("Array called");
}

public static  void doSomething(Integer obj) {
    System.out.println("Integer called");
}

When I am calling doSomething(null) , then compiler throws error as ambiguous methods. So is the issue because Integer and char[] methods or Integer and Object methods?

javaoopnulloverloading


Solution 1:[1]

Each pair of these three methods is ambiguous by itself when called with a null argument. Because each parameter type is a reference type.

The following are the three ways to call one specific method of yours with null.

doSomething( (Object) null);
doSomething( (Integer) null);
doSomething( (char[]) null);

May I suggest to remove this ambiguity if you actually plan to call these methods with null arguments. Such a design invites errors in the future.

Solution 2:[2]

null is a valid value for any of the three types; so the compiler cannot decide which function to use. Use something like doSomething((Object)null) or doSomething((Integer)null) instead.

Solution 3:[3]

Every class in Java extends Object class.Even Integer class also extends Object. Hence both Object and Integer are considered as Object instance. So when you pass null as a parameter than compiler gets confused that which object method to call i.e. With parameter Object or parameter Integer since they both are object and their reference can be null. But the primitives in java does not extends Object.

Solution 4:[4]

I Have tried this and when there is exactly one pair of overloaded method and one of them has a parameter type Object then the compiler will always select the method with more specific type. But when there is more than one specific type, then the compiler throws an ambiguous method error.

Since this is a compile time event, this can only happen when one intentionally passes null to this method. If this is done intentionally then it is better to overload this method again with no parameter or create another method altogether.

Solution 5:[5]

there is an ambiguity because of doSomething(char[] obj) and doSomething(Integer obj) .

char[] and Integer both are same superior for null thats why they are in ambiguous .

Solution 6:[6]

class Sample{
  public static void main (String[] args) {
       Sample s = new Sample();
       s.printVal(null);

    } 
    public static void printVal(Object i){
        System.out.println("obj called "+i);
    }

    public static void printVal(Integer i){
        System.out.println("Int called "+i);
    }
}

The output is Int called null and so ambiguity is with char[] and Integer

Sources

This article follows the attribution requirements of Stack Overflow and is licensed under CC BY-SA 3.0.

Source: Stack Overflow

Solution Source
Solution 1
Solution 2 Lars Noschinski
Solution 3 Ankit
Solution 4 ItamarG3
Solution 5 chitrendra chaudhary
Solution 6 nagarjuna chimakurthi

Related Questions