Método de sobrecarga para argumento nulo

He agregado tres métodos con parámetros:

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");
}

Cuando llamo doSomething(null), el compilador arroja el error como métodos ambiguos . Entonces, ¿es el problema porque Integery los char[]métodos o Integery los Objectmétodos?

Java siempre intentará usar la versión aplicable más específica de un método que esté disponible (consulte JLS §15.12.2 ).

Object, char[]y Integertodos pueden tomarse nullcomo un valor válido. Por lo tanto, las 3 versiones son aplicables, por lo que Java tendrá que encontrar la más específica.

Como Objectes el supertipo de char[], la versión de matriz es más específica que la Objectversión. Entonces, si solo existen esos dos métodos, char[]se elegirá la versión.

Cuando están disponibles las versiones char[]y Integer, ambas son más específicas que Objectninguna, pero ninguna es más específica que la otra, por lo que Java no puede decidir a cuál llamar. En este caso, tendrá que mencionar explícitamente a cuál desea llamar enviando el argumento al tipo apropiado.

Tenga en cuenta que en la práctica este problema ocurre mucho más raramente de lo que uno podría pensar. La razón de esto es que solo sucede cuando está llamando explícitamente a un método con nullo con una variable de un tipo bastante inespecífico (como Object).

Por el contrario, la siguiente invocación sería perfectamente inequívoca:

char[] x = null;
doSomething(x);

Aunque todavía está pasando el valor null, Java sabe exactamente a qué método llamar, ya que tendrá en cuenta el tipo de variable.

Cada par de estos tres métodos es ambiguo en sí mismo cuando se llama con un nullargumento. Porque cada tipo de parámetro es un tipo de referencia.

Las siguientes son las tres formas de llamar a un método específico suyo con nulo.

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

¿Puedo sugerir eliminar esta ambigüedad si realmente planea llamar a estos métodos con nullargumentos? Tal diseño invita a errores en el futuro.

nulles un valor válido para cualquiera de los tres tipos; entonces el compilador no puede decidir qué función usar. Use algo como doSomething((Object)null)o en su doSomething((Integer)null)lugar.

Cada clase en Java extiende la clase Object. Incluso la clase Integer también extiende Object. Por lo tanto, tanto Object como Integer se consideran como instancia de Object. Entonces, cuando pasa nulo como parámetro, el compilador se confunde a qué método de objeto llamar, es decir, con parámetro Objeto o parámetro Entero, ya que ambos son objeto y su referencia puede ser nula. Pero las primitivas en java no extienden Object.

He intentado esto y cuando hay exactamente un par de métodos sobrecargados y uno de ellos tiene un tipo de parámetro Object, el compilador siempre seleccionará el método con un tipo más específico. Pero cuando hay más de un tipo específico, el compilador arroja un error de método ambiguo.

Dado que este es un evento de tiempo de compilación, esto solo puede suceder cuando uno intencionalmente pasa nulo a este método. Si esto se hace intencionalmente, es mejor sobrecargar este método nuevamente sin ningún parámetro o crear otro método por completo.

existe una ambigüedad debido a doSomething (char [] obj) y doSomething (Integer obj).

char [] e Integer son superiores para nulo, por eso son ambiguos.

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);
    }
}

El resultado es Int llamado nulo y la ambigüedad es con char [] e Integer