Frage Können zwei Java-Methoden denselben Namen mit unterschiedlichen Rückgabetypen haben? [Duplikat]


Diese Frage hat hier bereits eine Antwort:

Können zwei Java-Methoden die gleicher Name mit unterschiedlichen Rückgabetyp? Der Rückgabetyp der Methoden ist unterschiedlich und sie werden mit demselben Methodennamen deklariert.

Ist das erlaubt?


76
2018-04-06 04:25


Ursprung


Antworten:


Wenn beide Methoden dieselben Parametertypen, aber unterschiedliche Rückgabetypen haben, als dies nicht möglich ist. Von Java-Sprachspezifikation, Java SE 8 Edition, §8.4.2. Methodensignatur:

Zwei Methoden oder Konstruktoren, M und N, haben die gleiche Signatur, wenn sie den gleichen Namen, die gleichen Typparameter (falls vorhanden) haben (§ 8.4.4) und nach Anpassung der formalen Parametertypen von N an die Typparameter von M, die gleichen formalen Parametertypen.

Wenn beide Methoden unterschiedliche Parametertypen haben (also unterschiedliche Signatur haben), ist es möglich. Es heißt Überladen.


74
2018-04-06 04:29



Nur wenn sie verschiedene Parameter akzeptieren. Wenn keine Parameter vorhanden sind, müssen Sie andere Namen haben.

int doSomething(String s);
String doSomething(int); // this is fine


int doSomething(String s);
String doSomething(String s); // this is not

28
2018-04-06 04:28



Laut JLS können Sie jedoch aufgrund eines Feature / Bugs im Java 6/7 Compiler (Oracle JDK, OpenJDK, IBM JDK) nicht unterschiedliche Rückgabetypen für die gleiche Methodensignatur verwenden, wenn Sie Generics verwenden.

public class Main {
    public static void main(String... args) {
        Main.<Integer>print();
        Main.<Short>print();
        Main.<Byte>print();
        Main.<Void>print();
    }

    public static <T extends Integer> int print() {
        System.out.println("here - Integer");
        return 0;
    }
    public static <T extends Short> short print() {
        System.out.println("here - Short");
        return 0;
    }
    public static <T extends Byte> byte print() {
        System.out.println("here - Byte");
        return 0;
    }
    public static <T extends Void> void print() {
        System.out.println("here - Void");
    }
}

Drucke

here - Integer
here - Short
here - Byte
here - Void

Für mehr Details, Lies meinen Artikel hier


18
2018-04-06 06:28



Nein. Sowohl C ++ als auch Java erlauben kein Überladen auf den Rückgabetyp einer Funktion. Der Grund dafür ist, dass das Überladen auf den Rückgabetyp verwirrend sein kann (es kann für Entwickler schwierig sein vorherzusagen, welche Überladung aufgerufen wird). In der Tat gibt es diejenigen, die argumentieren, dass jede Überlastung in dieser Hinsicht verwirrend sein kann und empfehlen dagegen, aber selbst diejenigen, die Überladung bevorzugen, scheinen zuzustimmen, dass diese spezielle Form zu verwirrend ist.


6
2018-04-06 04:28



Sie können zwei Methoden mit denselben Argumenten und unterschiedlichen Rückgabetypen nur verwenden, wenn eine der Methoden geerbt ist und die Rückgabetypen kompatibel sind.

Beispielsweise:

public class A
{
    Object foo() { return null; }
}

public class B
    extends A
{
    String foo() { return null; }
}

4
2018-04-06 05:13



Nur wenn ihre Parameterdeklarationen sich vom Speicher unterscheiden.


2
2018-04-06 04:27



Die Java-Dokumentation besagt:

Der Compiler berücksichtigt beim Differenzieren von Methoden keinen Rückgabetyp, sodass Sie nicht zwei Methoden mit derselben Signatur deklarieren können, auch wenn sie einen anderen Rückgabetyp haben.

Sehen: http://docs.oracle.com/javase/tutorial/java/java00/methods.html


2
2017-07-17 09:01



Wenn es in der gleichen Klasse mit der gleichen Anzahl von Parametern mit den gleichen Typen und der gleichen Reihenfolge ist, dann ist es zum Beispiel nicht möglich:

int methoda(String a,int b) {
        return b;
}
String methoda(String b,int c) {
        return b;    
}

Wenn die Anzahl der Parameter und deren Typen gleich ist, aber die Reihenfolge unterschiedlich ist, ist dies möglich, da dies zu einer Überladung der Methode führt. Dies bedeutet, dass die Methodensignatur dieselbe ist, die den Methodennamen mit der Anzahl der Parameter und deren Typen und der Reihenfolge, in der sie definiert sind, enthält.


1
2017-11-13 18:16



Auch wenn es ein alter Faden ist, interessiert sich vielleicht jemand.

Wenn es eine Option für Sie ist, die gleichMethode innerhalb der gleichen Klasse und archivieren Sie verschiedene Rückgabetypen, verwenden Sie Generika: Oracle Lesson Generics

Einfaches Beispiel für eine generische Werthalterklasse:

class GenericValue<T> {
  private T myValue;

  public GenericValue(T myValue) { this.myValue = myValue; }

  public T getVal() { return myValue; }
}

Und benutze es so:

public class ExampleGenericValue {
  public static void main(String[] args) {
    GenericValue<Integer> intVal = new GenericValue<Integer>(10);
    GenericValue<String> strVal = new GenericValue<String>("go on ...");

    System.out.format("I: %d\nS: %s\n", intVal.getVal(), strVal.getVal());
  }
}

... ergibt folgende Ausgabe:

I: 10
S: go on ...

1
2017-07-08 12:06