La firma di un metodo in Java include il tipo restituito?

La firma del metodo in una classe / interfaccia Java include il tipo restituito?

Esempio:

Java conosce la differenza tra questi due metodi:

public class Foo {
    public int  myMethod(int param) {}
    public char myMethod(int param) {}
}

O forse sono solo il nome del metodo e l'elenco dei parametri che contano?

Citando da Oracle Docs :

Definizione: due dei componenti di una dichiarazione di metodo comprendono la firma del metodo: il nome del metodo ei tipi di parametro.

Poiché la domanda è stata modificata per includere questo esempio:

public class Foo {
    public int  myMethod(int param) {}
    public char myMethod(int param) {}
}

No, il compilatore non conoscerà la differenza, poiché la loro firma: myMethod(int param)è la stessa. La seconda riga:

    public char myMethod(int param) {}

ti darà un errore: il metodo è già definito nella classe , il che conferma ulteriormente l'affermazione sopra.

La firma del metodo di classe in Java include il tipo restituito?

In Java, non lo fa, ma in questa JVM lo fa, il che può portare a un'ovvia confusione.

La firma del metodo di interfaccia in Java include il tipo restituito?

Lo stesso dei metodi di classe.

O solo il nome del metodo e l'elenco dei parametri?

Nome del metodo e tipi di parametri per Java. Ad esempio, le annotazioni e i nomi dei parametri non sono importanti.

A livello di bytecode, il "tipo restituito" fa parte della firma del metodo. Considera questo

public class Test1  {
    public Test1 clone() throws CloneNotSupportedException {
        return (Test1) super.clone();
    }
}

in bytecode ci sono 2 metodi clone ()

public clone()LTest1; throws java/lang/CloneNotSupportedException 

public clone()Ljava/lang/Object; throws java/lang/CloneNotSupportedException 

differiscono solo per il tipo restituito.

No, non in Java. Il nome del metodo e l'elenco dei parametri sono solo per la firma del metodo . Il tipo restituito non include.

Java Language Spec dice

Due metodi hanno la stessa firma se hanno lo stesso nome e tipi di argomenti.

quindi No, il tipo restituito non fa parte della firma del metodo.

In JAVA e in molte altre lingue, puoi chiamare un metodo senza una variabile per contenere il valore restituito. Se il tipo restituito fa parte della firma di un metodo, non è possibile sapere quale metodo verrà chiamato durante la chiamata senza specificare il valore di ritorno della variabile.

Bro, In java, usiamo per chiamare metodi con il loro nome e i loro parametri solo per usarli nel nostro codice, come

myMethod (20, 40)

quindi, JAVA cerca solo roba simile corrispondente nella dichiarazione corrispondente (nome + parametro), questo è il motivo per cui la firma del metodo include solo il nome e i parametri del metodo. :)

La firma del metodo è solo il nome e l'elenco dei parametri.

no, in Java la firma del metodo non include il tipo restituito, ma la dichiarazione sì.

public             String         getString(String myString)

^access modifier   ^return type   ^name    ^parameter type and name

modificato in base al feedback di seguito :)

Il tipo restituito non è incluso nella firma del metodo Solo il nome del metodo e i parametri sono definiti come firma del metodo.

Reffer: "Definizione dei metodi" di Oracle Docs

Utilizzando AspectJ (org.aspectj.lang.reflect.MethodSignature), ha il tipo di ritorno

IL METODO FIRMA COMPRENDE IL TIPO DI RESO.

Il compilatore lo ignora quando deve controllare i duplicati. Per Java è illegale avere due metodi con la firma che differisce solo dal tipo restituito.

Prova questo:

public class Called {
    public String aMethod() {
        return "";
    }
}

public class Caller {
    public static void main(String[] main) {
        aMethod();
    }
    public static void aMethod() {
        Called x = new Called();
        x.aMethod();
    }
}

Costruisci il progetto, vai alla directory bin, copia Caller.cass da qualche parte. Quindi cambia il metodo chiamato:

public int aMethod() {
    return 0;
}

Crea il progetto, vedrai che sia Called.class che Caller.class hanno un nuovo timestamp. Sostituisci Caller.class sopra ed esegui il progetto. Avrai un'eccezione:

java.lang.NoSuchMethodError: it.prova.Called.aMethod()Ljava/lang/String;

La firma del metodo è solo il nome e i parametri del metodo. Ma credo che il tuo esempio genererà un errore se dovessero essere nella stessa classe. Puoi semplicemente testarlo su qualsiasi ide e vedere che il compilatore genererà un errore

Se provi a eseguire il codice che hai menzionato su eclipse, avrai una risposta su quali elementi cerca il compilatore java differenziando tra i metodi java:

class Foo {
    public int  myMethod(int param) {
        return param;}
    public char *myMethod*(int param) { //this line throws an error 
        return param;
    }
}

L'errore generato è: metodo duplicato myMethod (int) nel tipo Foo.