Come viene scelto un metodo sovraccarico quando un parametro è il valore null letterale?

Mi sono imbattuto in questa domanda in un quiz,

public class MoneyCalc {

   public void method(Object o) {
      System.out.println("Object Verion");
   }

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

   public static void main(String args[]) {
      MoneyCalc question = new MoneyCalc();
      question.method(null);
   }
}

L'output di questo programma è "String Version". Ma non sono stato in grado di capire perché il passaggio di un valore nullo a un metodo sovraccarico ha scelto la versione stringa. Null è una variabile String che punta a nulla?

Tuttavia, quando il codice viene modificato in,

public class MoneyCalc {

   public void method(StringBuffer sb) {
      System.out.println("StringBuffer Verion");
   }

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

   public static void main(String args[]) {
      MoneyCalc question = new MoneyCalc();
      question.method(null);
   }
}

dà un errore di compilazione che dice "Il metodo del metodo (StringBuffer) è ambiguo per il tipo MoneyCalc"

Null è una variabile String che punta a nulla?

Un riferimento null può essere convertito in un'espressione di qualsiasi tipo di classe. Quindi, nel caso di String, va bene:

String x = null;

L' Stringoverload qui viene scelto perché il compilatore Java sceglie l' overload più specifico , come da sezione 15.12.2.5 del JLS . In particolare:

L'intuizione informale è che un metodo è più specifico di un altro se qualsiasi invocazione gestita dal primo metodo può essere passata all'altro senza un errore di tipo in fase di compilazione.

Nel tuo secondo caso, entrambi i metodi sono ancora applicabili, ma né Stringné StringBufferè più specifico dell'altro, quindi nessuno dei due metodi è più specifico dell'altro, da qui l'errore del compilatore.

Inoltre, JLS 3.10.7 dichiara anche che "null" è un valore letterale di "tipo null". Quindi esiste un tipo chiamato "null".

Successivamente, JLS 4.1 afferma che esiste un tipo null di cui è impossibile dichiarare le variabili, ma è possibile utilizzarlo solo tramite il letterale null. Successivamente si dice:

Il riferimento null può sempre subire una conversione di riferimento di ampliamento in qualsiasi tipo di riferimento.

Perché il compilatore sceglie di estenderlo a String potrebbe essere spiegato nella risposta di Jon .

È possibile assegnare a stringa un nullvalore in modo che sia valido e l'ordine per java e la maggior parte dei linguaggi di programmazione sia adatto al tipo più vicino e quindi all'oggetto.

Per rispondere alla domanda nel titolo: nullnon è né un Stringné un Object, ma può essere assegnato un riferimento a entrambi null.

In realtà sono sorpreso che questo codice venga compilato. Ho provato qualcosa di simile in precedenza e ho ricevuto un errore del compilatore che diceva che la chiamata era ambigua.

Tuttavia, in questo caso, sembra che il compilatore stia scegliendo il metodo più basso nella catena alimentare. Si presume che tu voglia la versione meno generica del metodo per aiutarti.

Dovrò vedere se riesco a scavare l'esempio in cui ho ricevuto un errore del compilatore in questo (apparentemente) identico scenario, però ...]

EDIT: Capisco. Nella versione che ho creato, avevo due metodi sovraccarichi che accettano un Stringe un Integer. In questo scenario, non esiste un parametro "più specifico" (come in Objecte String), quindi non può scegliere tra di essi, a differenza del codice.

Domanda molto interessante!

Poiché il tipo String è più specifico del tipo Object. Supponiamo che tu aggiunga un altro metodo che accetta un tipo Integer.

public void method(Integer i) {
      System.out.println("Integer Version");
   }

Quindi riceverai un errore del compilatore che dice che la chiamata è ambigua. Come ora abbiamo due metodi ugualmente specifici con la stessa precedenza.

Il compilatore Java fornisce il tipo di classe più derivato per assegnare null.

Ecco l'esempio per capirlo:

class A{

    public void methodA(){
        System.out.println("Hello methodA");
    }
}

class B extends A{
    public void methodB(){
        System.out.println("Hello methodB");
    }
}

class C{
    public void methodC(){
        System.out.println("Hello methodC");
    }
}

public class MyTest {

     public static void fun(B Obj){
         System.out.println("B Class.");
     }
     public static void fun(A Obj){
         System.out.println("A Class.");
     }

    public static void main(String[] args) {
        fun(null);
    }
}

uscita: Classe B.

d'altro canto:

public class MyTest {

     public static void fun(C Obj){
         System.out.println("B Class.");
     }
     public static void fun(A Obj){
         System.out.println("A Class.");
     }

    public static void main(String[] args) {
        fun(null);
    }
}

Risultato: il metodo fun (C) è ambiguo per il tipo MyTest

Spero che possa aiutare a capire meglio questo caso.

Fonte: https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.12.2.5
Concetto: metodo più specifico
Spiegazione: se più di un metodo membro è accessibile e applicabile a una chiamata di metodo, è necessario sceglierne uno per fornire il descrittore per l'invio del metodo in fase di esecuzione. Il linguaggio di programmazione Java utilizza la regola che viene scelto il metodo più specifico. Prova a trasmettere il valore nullo a un tipo specifico e il metodo che desideri verrà chiamato automaticamente.

Direi nessuno dei due. NULL è uno stato, non un valore. Dai un'occhiata a questo link per maggiori informazioni su questo (l'articolo si applica a SQL, ma penso che aiuti anche con la tua domanda).