Surcharge de méthode pour l'argument nul

J'ai ajouté trois méthodes avec des paramètres:

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

Lorsque j'appelle doSomething(null), le compilateur renvoie une erreur en tant que méthodes ambiguës . Il en est de la question parce que Integeret les char[]méthodes ou Integeret Objectméthodes?

Java essaiera toujours d'utiliser la version applicable la plus spécifique d'une méthode disponible (voir JLS §15.12.2 ).

Object, char[]et Integerpeuvent tous prendre nullcomme valeur valide. Par conséquent, les 3 versions sont applicables, Java devra donc trouver la plus spécifique.

Puisqu'il Objects'agit du super-type de char[], la version du tableau est plus spécifique que la Object-version. Donc, si seulement ces deux méthodes existent, la char[]version sera choisie.

Lorsque les versions char[]et Integersont disponibles, les deux sont plus spécifiques, Objectmais aucune n'est plus spécifique que l'autre, de sorte que Java ne peut pas décider laquelle appeler. Dans ce cas, vous devrez mentionner explicitement celui que vous souhaitez appeler en convertissant l'argument dans le type approprié.

Notez qu'en pratique, ce problème se produit beaucoup plus rarement qu'on ne le pense. La raison en est que cela ne se produit que lorsque vous appelez explicitement une méthode avec nullou avec une variable d'un type plutôt non spécifique (comme Object).

Au contraire, l'invocation suivante serait parfaitement claire:

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

Bien que vous passiez toujours la valeur null, Java sait exactement quelle méthode appeler, car elle prendra en compte le type de variable.

Chaque paire de ces trois méthodes est ambiguë en soi lorsqu'elle est appelée avec un nullargument. Parce que chaque type de paramètre est un type de référence.

Voici les trois façons d'appeler une de vos méthodes spécifiques avec null.

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

Puis-je suggérer de supprimer cette ambiguïté si vous envisagez d'appeler ces méthodes avec des nullarguments. Une telle conception invite à des erreurs dans le futur.

nullest une valeur valide pour l'un des trois types; donc le compilateur ne peut pas décider quelle fonction utiliser. Utilisez quelque chose comme doSomething((Object)null)ou à la doSomething((Integer)null)place.

Chaque classe en Java étend la classe Object, et même la classe Integer étend également Object. Par conséquent, Object et Integer sont tous deux considérés comme une instance Object. Ainsi, lorsque vous passez null comme paramètre, le compilateur se confond avec la méthode objet à appeler, c'est-à-dire avec le paramètre Object ou le paramètre Integer, car ils sont tous les deux des objets et leur référence peut être nulle. Mais les primitives de java n'étendent pas Object.

J'ai essayé cela et quand il y a exactement une paire de méthodes surchargées et que l'une d'elles a un type de paramètre Object, le compilateur sélectionnera toujours la méthode avec un type plus spécifique. Mais lorsqu'il y a plus d'un type spécifique, le compilateur renvoie une erreur de méthode ambiguë.

Puisqu'il s'agit d'un événement au moment de la compilation, cela ne peut se produire que lorsque l'on passe intentionnellement null à cette méthode. Si cela est fait intentionnellement, il est préférable de surcharger à nouveau cette méthode sans paramètre ou de créer une autre méthode.

il y a une ambiguïté à cause de doSomething (char [] obj) et doSomething (Integer obj).

char [] et Integer sont tous les deux supérieurs pour null, c'est pourquoi ils sont ambigus.

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

La sortie est Int appelée null et donc l'ambiguïté est avec char [] et Integer