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




tipos primitivos java (8)

@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 ... :)

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?


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

}

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
     }

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

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. .


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!
    }

}


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.


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 ...





return-type