Utilizzando nulla a metodi di overload in Java

Question

Eventuali duplicati:
Method Overloading for NULL parameter

Il seguente codice compila e va bene.

public class Main 
{ 
    public void temp(Object o) 
    { 
     System.out.println("The method with the receiving parameter of type Object has been invoked."); 
    } 

    public void temp(String s) 
    { 
     System.out.println("The method with the receiving parameter of type String has been invoked."); 
    } 

    public void temp(int i) 
    { 
     System.out.println("The method with the receiving parameter of type int has been invoked."); 
    } 

    public static void main(String[] args) 
    { 
     Main main=new Main(); 
     main.temp(null); 
    } 
} 

In questo codice, il metodo da richiamare è quella che accetta il parametro di tipo String

Il docs dire.

Se più di un metodo membro è accessibile e applicabile ad una chiamata di metodo , è necessario scegliere uno di fornire il descrittore per il metodo di spedizione in fase di esecuzione. La lingua Java programmazione utilizza la regola che il metodo più specifico è scelto.

ma non capisco quando uno dei metodi nel codice che accetta il parametro della primitiva int viene modificato per accettare il parametro del tipo involucro Integer quali,

public void temp(Integer i) 
{ 
    System.out.println("The method with the receiving parameter of type Integer has been invoked."); 
} 

un viene generato un errore in fase di compilazione.

riferimento alla temp è ambigua, sia metodo temperatura (java.lang.String) in methodoverloadingpkg.Main e metodo temp (java.lang.Integer) in methodoverloadingpkg.Main partita

In questo particolare scenario, perché è legale sovraccaricare un metodo con un tipo di dati primitivo che tuttavia non sembra essere il caso con il suo tipo di wrapper corrispondente?

Answer 1

Se ti è stato chiesto cosa sia "Stringa" o "Oggetto" più specializzato, cosa diresti? Evidentemente "String", giusto?

Se ti è stato chiesto: cos'è "String" o "Integer" più specializzato? Non c'è risposta, sono entrambe specializzazioni ortogonali di un oggetto, come puoi scegliere tra loro? Quindi devi essere esplicito riguardo a quale vuoi. Per esempio lanciando il vostro riferimento null:

question.method((String)null) 

Quando si utilizza tipi primitivi voi non hanno questo problema, perché "null" è un tipo di riferimento e non può entrare in conflitto con i tipi primitivi. Ma quando si usano i tipi di riferimento "null" potrebbe fare riferimento a String o Integer (poiché il null può essere lanciato su qualsiasi tipo di riferimento di riferimento) .

Vedere the answer in the other question che ho postato nei commenti sopra per ulteriori e più approfonditi dettagli e anche alcune citazioni dal JLS.

Answer 2

Dove si passa null come argomento per un metodo di overload, il metodo scelto è il metodo con il tipo più specializzata, quindi in questo caso: String viene scelto, piuttosto che la più tollerante: Object.

Tra Object/String/int la scelta è chiara per il compilatore: otterrete s' il String uno causa un int non può essere null e così il suo metodo corrispondente non è idoneo a essere chiamato in questo caso.

Ma se si cambia int per Integer, compilatore sarà confondere, perché entrambi i metodi prendendo String è accurato come Integer s' uno (ortogonale gerarchia).

E il compilatore non può (non vuole? ^^) scegliere a caso.

Answer 3

Prima di capire perché main.temp(null); si risolve in temp(String s) e non in temp(Object o) Ti punto alla mia vecchia risposta a Java method dispatch with null argument. In sostanza, il valore letterale null è di tipo nulltype e Object < String < nulltype. Quindi null è più vicino a String quindi è a Object.

Ora, null è il più vicino a String quanto lo è per Integer, in modo che quando si aggiunge test(Integer) diventa ambiguo