Perché il tipo di ritorno del metodo non è incluso nella firma del metodo?

Question

Perché il tipo di metodo restituito non è incluso nella firma?

A titolo di esempio -

public void method1(String arg){...} 

public String method1(String arg){...} 

Esso provocherà un errore

Answer 1

Questo perché il compilatore non sarebbe in grado di calcolare il sovraccarico in tutti i contesti.

Ad esempio, se si chiama

String x = method1("aaa"); 

il compilatore sa che si sta cercando per il secondo sovraccarico. Tuttavia, se si chiama

method1("aaa"); 

come questo, il compilatore non ha idea che uno dei due metodi si voleva richiamare, perché è OK per chiamare un metodo che restituisce String e scartare il risultato. Per evitare ambiguità come questa, Java proibisce sovraccarichi che differiscono unicamente sul tipo di ritorno.

Answer 2

Non si può sovraccaricare un metodo solo su di esso la tipo di ritorno. È semplicemente illegale. Supponiamo per un momento che i metodi di overload che utilizzano il tipo restituito siano legali e sono stati definiti due metodi method1. Ora vogliamo chiamare ciò che restituisce il String object:

String string = method1(sth);

La JVM in teoria sarebbe in grado di riconoscere quale metodo si in questione, destinate a chiamare, ma per quanto riguarda tale chiamata:

method1(sth);

Come puoi vedere, entrambi i metodi potrebbero essere richiamati e tali operazioni non sono ambigue. La JVM non sa quale metodo dovrebbe chiamare. Questo è il motivo per cui tale sovraccarico è vietato.

Answer 3

è possibile chiamare la funzione come procedura: method1("arg"); dove method1 è il secondo metodo nell'elenco (String method1(String arg){}). Il compilatore quindi non sarebbe in grado di distinguerlo dal primo (void method1(String arg){}).

Answer 4

Poiché è impossibile risolvere quale dei metodi di overload dovrebbe essere chiamato in un caso come questo:

public static void main(String... args) { 
    method1("aaa"); 
} 

Answer 5

Methode sovraccarico viene controllato sulla base del numero e tipo di argomenti non sulla base di ritorno tipo. Questo è il motivo per cui stai ricevendo errore.

Answer 6

Poiché la tua domanda non si riferisce ad alcun particolare linguaggio di programmazione nel titolo (lo so che fa nel tag) condividerò la mia recente esperienza con Swift. In Swift la funzione/firma del metodo include effettivamente il tipo restituito. Così compilatore genera un errore solo se si chiama questa funzione/metodo senza specificare esplicitamente tipo di ritorno, ad es .:

func some() -> Bool { 
    return true; 
} 

func some() -> Int { 
    return 1; 
} 

let valBool: Bool = some() 
let valInt: Int = some() 

// this doesn't work: Ambiguous use of 'some' 
some() 

In cima a questo Swift ancora lo rende più interessante. Ti consente di avere 2 funzioni/metodi con gli stessi parametri e tipi di ritorno solo se i nomi dei parametri sono diversi, ad es.:

func some(#foo: Bool) -> Bool { 
    return foo; 
} 

func some(#bar: Bool) -> Bool { 
    return bar; 
} 

some(foo: true) 
some(bar: false) 

Così ti dà differenziazione semantica nei metodi di firma

UPD. Dal momento che Swift 2.0 esterno nome del parametro è stato cambiato e ora è necessario fornire i nomi esterni e locali due volte anche se è lo stesso

func some(foo foo: Bool) -> Bool { 
    return foo; 
} 

func some(bar bar: Bool) -> Bool { 
    return bar; 
} 

some(foo: true) 
some(bar: false) 

Answer 7

Ci sono diversi punti da considerare nella progettazione di cose come la risoluzione di sovraccarico.

motivi per omettere sovraccarico sul tipo di ritorno:

1. Semplificare ignorando il valore di ritorno della funzione (come le persone fanno spesso con i codici di errore).
2. Rende il programma più facile da digerire per i lettori umani. In particolare, questa è la ragione per cui in Python non hanno affatto sovraccarichi di funzione. (questione di gusti)
3. C legacy. Quando la lingua viene da C-famiglia e progettisti non considerano qualcosa di cui essere un grosso problema che viene lasciato come è sempre stato ...

ragioni per aggiungere sovraccarico sul tipo di ritorno:

1. Marchio è difficile ignorare i valori restituiti. Questo può essere conveniente e consente di risparmiare un po 'di digitazione, ma sicuramente ti morderà un giorno.
2. Espressività (ovviamente in contrasto con la facilità di digerire :)). Hai mai desiderato scrivere cose come int x = json.get("int_value"); float y = json.get("float_value");? In alcuni linguaggi (come C++) che è ancora possibile ottenere con i proxy e gli operatori cast, ma il sovraccarico sul tipo restituito sarebbe molto più semplice.
3. Espressività. Ogni volta che si passa il valore di retun come riferimento alla propria funzione solo per riutilizzare le sue risorse questo potrebbe essere un sovraccarico sul tipo restituito (con il parametro nascosto simile). Si consideri string s; getline(cin, s); vs string s = getline(cin);. Ed è qui che l'espressività si unisce alla trasparenza referenziale e, alla fine, alla facilità di digerire il codice.

Ora torna alla tua domanda "perché?". Dal momento che stavi chiedendo di Java, la risposta è ovviamente perché James ha apprezzato i motivi per omettere i sovraccarichi di tipo restituito sui motivi per includerli nella lingua.