¿Pueden dos métodos Java tener el mismo nombre con diferentes tipos de devolución?

Question

¿Pueden dos métodos Java tener el mismo nombre con diferente tipo de retorno? El tipo de devolución de los métodos es diferente y se declaran con el mismo nombre de método.

¿Eso está permitido?

Answer 1

Solo si sus declaraciones de parámetros son diferentes de la memoria.

Answer 2

Solo si aceptan otros parámetros. Si no hay parámetros, entonces debe tener diferentes nombres.

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


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

Answer 3

Nº C++ y Java tanto no permitir la sobrecarga de tipo de retorno de una función. La razón es que la sobrecarga en el tipo de retorno puede ser confusa (puede ser difícil para los desarrolladores predecir a qué sobrecarga se llamará). De hecho, hay quienes argumentan que cualquier sobrecarga puede ser confusa a este respecto y recomendar en contra, pero incluso aquellos que están a favor de la sobrecarga parecen estar de acuerdo en que esta forma particular es demasiado confusa.

Answer 4

Si ambos métodos tienen los mismos tipos de parámetros, pero diferente tipo de devolución que no es posible. De Java Language Specification, Java SE 8 Edition, §8.4.2. Method Signature:

dos métodos o constructores, M y N, tienen la misma firma si tienen el mismo nombre, los mismos parámetros de tipo (si los hay) (§8.4.4), y, después de la adaptación de los formales tipos de parámetros de N a los parámetros de tipo de M, los mismos tipos de parámetros formales.

Si ambos métodos tienen diferentes tipos de parámetros (por lo tanto, tienen una firma diferente), entonces es posible. Se llama sobrecarga.

Answer 5

Puede tener dos métodos con los mismos argumentos y diferentes tipos de devolución solo si uno de los métodos es heredado y los tipos de devolución son compatibles.

Por ejemplo:

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

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

Answer 6

Según el JLS, no puede sin embargo debido a una característica/error en el compilador de Java 6/7 (JDK de Oracle, OpenJDK, el JDK de IBM) puede tener diferentes tipos de retorno para la misma firma de método si usa genéricos.

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"); 
    } 
} 

imprime

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

Para más detalles, read my article here

Answer 7

Si está en la misma clase con el mismo número de parámetros con los mismos tipos y orden, entonces no es posible ejemplo:

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

si el número de parámetros y sus tipos es el mismo pero el orden es diferente, entonces es posible, ya que da como resultado la sobrecarga del método. Significa si la firma del método es la misma, lo que incluye el nombre del método con el número de parámetros y sus tipos y el orden en que se definen.

Answer 8

La documentación de Java:

El compilador no tiene en cuenta el tipo de retorno al diferenciar métodos, por lo que no se puede declarar dos métodos con la misma firma, incluso si tienen un tipo de retorno diferente.

Ver: http://docs.oracle.com/javase/tutorial/java/javaOO/methods.html

Answer 9

Incluso si se trata de un viejo hilo, tal vez algunos se interesa.

Si se trata de una opción para que usted pueda utilizar el mismo método dentro de la misma clase y archivar diferentes tipos de retorno, utilice los genéricos: Oracle Lesson Generics

ejemplo simple para la clase de soporte de valor genérico:

class GenericValue<T> { 
    private T myValue; 

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

    public T getVal() { return myValue; } 
} 

Y

utilizar de esta manera:

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()); 
    } 
} 

... resultará en la siguiente salida:

I: 10 
S: go on ...