Tipo de devolución genérico de Java

Question

Me gustaría escribir un método que pueda aceptar un tipo param (o lo que sea que el método pueda deducir del tipo) y devolver un valor de este tipo para que no tenga que emitir el retorno tipo.

Aquí es un método:

public Object doIt(Object param){ 
    if(param instanceof String){ 
     return "string"; 
    }else if(param instanceof Integer){ 
     return 1; 
    }else{ 
     return null; 
    } 
} 

Cuando llamo a este método, y paso en ella una cadena, aunque sé que el tipo de retorno será una cadena que tengo que convertir el objeto de retorno. Esto es similar al int param.

¿Cómo debo escribir este método para aceptar un tipo param y devolver este tipo?

Answer 1

si no quiere tener una interfaz específica para manejar ese material se puede utilizar un método genérico de esta manera:

public <T> T mymethod(T type) 
{ 
    return type; 
} 

cuenta que en De esta manera, el compilador no sabe nada sobre el tipo que planea usar dentro de ese método, por lo que debe usar un tipo vinculado, por ejemplo:

public <T extends YourType> T mymethod(T type) 
{ 
    // now you can use YourType methods 
    return type; 
} 

Pero debe asegurarse de que necesita un método genérico, lo que significa que la implementación de doIt será la misma para todos los tipos con los que planea usarla. De lo contrario, si cada aplicación es diferente solo sobrecargar los métodos, no tendrán ningún problema ya que el tipo de retorno no se utiliza para el enlace dinámico:

public String my(String s) 
{ 
    return s; 
} 

public int my(int s) 
{ 
    return s; 
} 

int i = my(23); 
String s = my("lol"); 

Answer 2

de inicio con esto:

public interface Command<T> 
{ 
    T execute(T parameter); 
} 

Answer 3

te instaría a NO uso instanceof, sin embargo este código hace lo usted quiere:

public class Main 
{ 
    public static void main(String[] args) 
    { 
     final Main main; 
     final String strVal; 
     final Integer intVal; 
     final Float floatVal; 

     main  = new Main(); 
     strVal = main.doIt("Hello"); 
     intVal = main.doIt(5); 
     floatVal = main.doIt(5.0f); 

     System.out.println(strVal); 
     System.out.println(intVal); 
     System.out.println(floatVal); 
    } 

    public <T> T doIt(final T thing) 
    { 
     T t; 

     if(thing instanceof String) 
     { 
      t = (T)"String"; 
     } 
     else if (thing instanceof Integer) 
     { 
      t = (T)Integer.valueOf(1); 
     } 
     else 
     { 
      t = null; 
     } 

     return (t); 
    } 
} 

Answer 4

La respuesta corta es no. Tan pronto como se involucre instanceof, los genéricos suelen ser la respuesta incorrecta. Use métodos sobrecargados en su lugar:

public String doIt(String param){ 
    return "string"; 
} 

public Integer doIt(Integer param){ 
    return 1; 
} 

public Object doIt(Object param){ 
    return null; 
}