resultado - mostrar texto en jtextfield java

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

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Sobrecarga con diferente tipo de retorno en Java? 8 respuestas

¿Pueden dos métodos Java tener el mismo nombre con diferente tipo de devolución ? 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

De acuerdo con el JLS, no puede, sin embargo, debido a una característica / error en el compilador Java 6/7 (JDK de Oracle, OpenJDK, JDK de IBM) puede tener diferentes tipos de devolución 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");
    }
}

Huellas dactilares

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

Para más detalles, lee mi artículo aquí

Answer 2

Incluso si se trata de un hilo viejo, tal vez algunos estén interesados.

Si es una opción para usted utilizar el mismo método dentro de la misma clase y archivar diferentes tipos de devolución, use genéricos: Oracle Lesson Generics

Ejemplo simple para clase de titular de valor genérico:

class GenericValue<T> {
  private T myValue;

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

  public T getVal() { return myValue; }
}

Y úsalo así:

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

... dará como resultado la siguiente salida:

I: 10
S: go on ...

Answer 3

La documentación de Java dice:

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

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

Answer 4

No. C ++ y Java no permiten la sobrecarga en el tipo de devolución 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 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

Si ambos métodos tienen los mismos tipos de parámetros, pero diferente tipo de devolución que no es posible. De la especificación del lenguaje Java, Java SE 8 Edition, §8.4.2. Firma del método :

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 adaptar los tipos de parámetros formales 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 7

Si está en la misma clase con el mismo número de parámetros con los mismos tipos y el mismo orden, entonces no es posible, por 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, 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

Solo si aceptan diferentes 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 9

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