primitivos - tipos de variables en java ejemplos

¿Devuelve diferentes tipos de datos de un método en java?

Question

public static void main(String args[]) {
    myMethod(); // i am calling static method from main()
 }

.

public static ? myMethod(){ // ? = what should be the return type
    return value;// is String
    return index;// is int
}

myMethod() devolverá String y valor int. Entonces, tome estos valores de retorno de main() me ocurrió la siguiente solución.

crear una llamada de clase ReturningValues

public class ReturningValues {
private String value;
private int index;

// getters and setters here
}

y cambie myMethod() siguiente manera.

 public static ReturningValues myMethod() {
    ReturningValues rv = new ReturningValues();
    rv.setValue("value");
    rv.setIndex(12);
    return rv;
}

Ahora mi pregunta, ¿hay alguna manera más fácil de lograr esto?

Answer 1

@ruchira es la solución en sí misma. Pero creo que si solo se trata de un entero y una cadena, podemos hacerlo de una forma muy sencilla y sencilla.

 class B {   
    public String myfun() {         
        int a=2;           //Integer .. you could use scanner or pass parameters ..i have simply assigned
        String b="hi";      //String
        return Integer.toString(a)+","+b; //returnig string and int with "," in middle          
    }       
}

class A {    
    public static void main(String args[]){

        B obj=new B();  // obj of class B with myfun() method  
        String returned[]=obj.myfun().split(",");
             //splitting integer and string values with "," and storing them in array   
        int b1=Integer.parseInt(returned[0]); //converting first value in array to integer.    
        System.out.println(returned[0]); //printing integer    
        System.out.println(returned[1]); //printing String
    }
}

Espero que haya sido útil ... :)

Answer 2

Creo varios tipos de devolución utilizando enum. No se define automáticamente. Esa implementación parece un patrón de fábrica.

public  enum  SmartReturn {

    IntegerType, DoubleType;

    @SuppressWarnings("unchecked")
    public <T> T comeback(String value) {
        switch (this) {
            case IntegerType:
                return (T) Integer.valueOf(value);
            case DoubleType:
                return (T) Double.valueOf(value);
            default:
                return null;
        }
    }
}

Prueba de unidad:

public class MultipleReturnTypeTest {

  @Test
  public void returnIntegerOrString() {
     Assert.assertTrue(SmartReturn.IntegerType.comeback("1") instanceof Integer);
     Assert.assertTrue(SmartReturn.DoubleType.comeback("1") instanceof Double);
  }

}

Answer 3

El enfoque que tomaste es bueno. La implementación justa puede necesitar ser mejor. Por ejemplo, ReturningValues ​​debe estar bien definido y es mejor si puede hacer que ReturningValues ​​sea inmutable .

// this approach is better
public static ReturningValues myMethod() {
    ReturningValues rv = new ReturningValues("value", 12);
    return rv;
}


public final class ReturningValues {
    private final String value;
    private final int index;


    public ReturningValues(String value, int index) {
      this.value = value;
      this.index = index;
     }

} 

O si tiene muchos pares de valores clave, puede usar HashMap entonces

public static Map<String,Object> myMethod() {
  Map<String,Object> map = new HashMap<String,Object>();
  map.put(VALUE, "value");
  map.put(INDEX, 12);
  return Collections.unmodifiableMap(map); // try to use this 
}

Answer 4

En general, si no está seguro de qué valor terminará devolviendo, debe considerar el uso de tipo de retorno como superclase de todos los valores de retorno. En este caso, cuando necesite devolver String o int, considere devolver la clase Object (que es la clase base de todas las clases definidas en java).

Pero tenga cuidado de tener instancias de verificación donde está llamando este método. O bien, puede terminar obteniendo ClassCastException .

public static void main(String args[]) {
        Object obj = myMethod(); // i am calling static method from main() which return Object
    if(obj instanceof String){
    // Do something
    }else(obj instance of Integer) {
    //do something else
     }

Answer 5

Esta puede ser una de las soluciones. Pero tu solución actual es lo suficientemente buena. También puede agregar nuevas variables y mantenerlo limpio, lo que no se puede hacer con el código actual.

private static final int INDEX_OF_STRING_PARAM = 0;
private static final int INDEX_OF_INT_PARAM = 1;

public static Object[] myMethod() {
    Object[] values = new Object[2];
    values[INDEX_OF_STRING_PARAM] = "value";
    values[INDEX_OF_INT_PARAM] = 12;
    return values;
}

Answer 6

Finalmente, pensé que mi camino es mejor, ya que cuando la cantidad de tipos de retorno aumenta, este tipo de implementación lo hace de la mejor manera.

public static ReturningValues myMethod() {
ReturningValues rv = new ReturningValues();
rv.setValue("value");
rv.setIndex(12);
return rv;
}

Answer 7

La clase que estás buscando ya existe. Map.Entry :

public static Entry<Integer,String> myMethod(){
    return new SimpleEntry<>(12, "value");
}

Y después:

Entry<Integer,String> valueAndIndex = myMethod();
int index = valueAndIndex.getKey();
String value = valueAndIndex.getValue();

Es solo una simple estructura de datos de dos campos que almacena una clave y un valor. Si necesita realizar un procesamiento especial, almacenar más de dos campos o tener cualquier otro caso complementario, debe crear su propia clase, pero de lo contrario, Map.Entry es una de las clases de Java más infrautilizadas y es perfecta para situaciones como estas. .

Answer 8

Método de sobrecarga puede ser útil aquí como:

<code>
public class myClass 
{
    int add(int a, int b) 
    {
         return (a + b);
    }

    String add(String a, String b)
    {
         return (c + d);
    }

    public static void main(String args[]) 
    {
        myClass ob1 = new myClass);
        ob1.add(2, 3);
        //will return 5
        ob1.add("Hello, ", "World!");
        //will return Hello, World!
    }

}

Answer 9

No. Los métodos Java solo pueden devolver un resultado ( void , un objeto primitivo o un objeto), y crear una clase de tipo struct como esta es exactamente cómo lo haces.

Como nota, con frecuencia es posible hacer que clases como tu ReturningValues inmutables de esta manera:

public class ReturningValues {
    public final String value;
    public final int index;

    public ReturningValues(String value, int index) {
        this.value = value;
        this.index = index;
    }
}

Esto tiene la ventaja de que los ReturningValues se pueden pasar, como por ejemplo, entre hilos, sin preocuparse de que las cosas no estén sincronizadas accidentalmente.

Answer 10

Sé que esto es tarde, pero pensé que sería útil para alguien que venga a buscar una respuesta a esto. Puede usar un Bundle para devolver varios valores de tipo de datos sin crear otro método. Lo probé y funcionó perfectamente.

En tu MainActivity donde llamas al método:

Bundle myBundle = method();
String myString = myBundle.getString("myS");
String myInt = myBundle.getInt("myI");

Método:

public Bundle method() {
    mBundle = new Bundle();
    String typicalString = "This is String";
    Int typicalInt = 1;
    mBundle.putString("myS", typicalString);
    mBundle.putInt("myI", typicalInt);
    return mBundle;
}

PD: No estoy seguro de si está bien implementar un paquete como este, pero para mí, funcionó perfectamente.

Answer 11

Usted puede tener la devolución como un objeto. Usted crea ese objeto ''en marcha'' en su

function: if(int) 
 return new object(){
   int nr=..
}

lo mismo para la cadena. Pero me preocupa que sea una solución cara ...