wake-up-neo.com

Verschiedene Datentypen aus einer Methode in Java zurückgeben?

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() gibt den String- und Int-Wert zurück. Nehmen Sie diese Rückgabewerte von main()

einen Klassenaufruf erstellen ReturningValues

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

// getters and setters here
}

und myMethod() wie folgt ändern. 

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

Nun meine Frage, gibt es einen einfacheren Weg, das zu erreichen? 

Schließlich dachte ich, dass mein Weg besser ist, denn wenn die Anzahl der Rückgabetypen höher ist, kann diese Art der Implementierung dies auf die beste Art tun.

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

Nein. Java-Methoden können nur ein Ergebnis zurückgeben (void, ein Primitiv oder ein Objekt). Wenn Sie eine struct- Klasse erstellen, ist dies genau wie Sie es tun.

Als Hinweis ist es häufig möglich, Klassen wie Ihre ReturningValues unveränderlich wie folgt zu machen:

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

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

Dies hat den Vorteil, dass eine ReturningValues, z. B. zwischen Threads, weitergegeben werden kann, ohne sich Sorgen darüber zu machen, dass versehentlich Dinge aus dem Takt geraten.

17
chrylis

Ich erstelle verschiedene Rückgabetypen mit enum. Es wird nicht automatisch definiert. Diese Implementierung sieht aus wie ein Fabrikmuster.

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

Gerätetest:

public class MultipleReturnTypeTest {

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

}
17
Wendel

Wenn Sie nicht sicher sind, welchen Wert Sie zurückgeben möchten, sollten Sie generell den Rückgabetyp als Superklasse aller Rückgabewerte verwenden. In diesem Fall sollten Sie, wenn Sie String oder int zurückgeben müssen, die Object-Klasse (die Basisklasse aller in Java definierten Klassen) zurückgeben.

Achten Sie jedoch darauf, dass instanceof überprüft, wo Sie diese Methode aufrufen. Andernfalls erhalten Sie möglicherweise 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
     }
5
Ankur Shanbhag

Dies kann eine der Lösungen sein. Aber Ihre gegenwärtige Lösung ist gut genug. Sie können auch neue Variablen hinzufügen und trotzdem sauber halten, was mit dem aktuellen Code nicht möglich ist.

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;
}
1
Narendra Pathai

der Ansatz, den Sie gewählt haben, ist gut. Nur die Implementierung muss möglicherweise besser sein Zum Beispiel sollten ReturningValues ​​gut definiert sein und Es ist besser, wenn Sie ReturningValues ​​als immutable machen können.

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

} 

Wenn Sie viele Schlüsselwertpaare haben, können Sie HashMap dann verwenden 

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 
}
1
veritas

sie können die Rendite als Objekt erhalten. Sie erstellen das Objekt "on fly" in Ihrem 

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

gleiches für String. Aber ich bin besorgt, dass dies eine teure Lösung ist ...

1
Botea Florin

Ich möchte nur meine Ansicht vertreten 

Sie müssen also einen generischen Rückgabetyp erstellen, der von verschiedenen Typen von konkreten Rückgabetypen implementiert wird .. Die Service-Klasse kann verschiedene Arten von Objekten mit konkreter Klasse erstellen und als generischen Typ zurückgeben.

public interface GenericReturnType{
    public static RETURN_TYPE enum{
        MACHINE, PERSON;    
    }
    public RETURN_TYPE getReturnType();
}

public class PersonReturnType implements GenericReturnType{
    // CONSTRUCTORS //

    // GETTRE AND SETTER //

    public RETURN_TYPE getReturnType(){
        return PERSON;
    }
    public String getAddress(){
        return something;
    }
}

public class MachineReturnType implements GenericReturnType{
    // CONSTRUCTORS //

    // GETTRE AND SETTER //

    public RETURN_TYPE getReturnType(){
        return MACHINE;
    }
    public String getManufatureName(){
        return something;
    }
}


public class TestService{
    public GenericReturnType getObject(// some input //){
        GenericReturnType obj ;
        if(// some code //){
            obj = new  PersonReturnType();
            // some code //
        }
        if(// some code //){
            obj = new  MachineReturnType();
            // some code //
        }
        return obj;
    }
}

public class TestDriver{
    TestService service = new TestService();
    GenericReturnType genObj = TestService.getObject(// some input //);
    if(genObj.getReturnType() == RETURN_TYPE.MACHINE){
        // SOME CODE // 
    }
    if(genObj.getReturnType() == RETURN_TYPE.PERSON){
        // SOME CODE // 
    }
}
0
ParagFlume

@ruchira ur lösung ist es selbst am besten. Aber ich denke, wenn es nur um eine ganze Zahl und eine Zeichenfolge geht, können wir es auf eine sehr einfache und einfache Weise tun.

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

ich hoffe es war nützlich .. :)

0

Die von Ihnen gesuchte Klasse existiert bereits. Map.Entry :

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

Und später:

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

Es ist nur eine einfache Datenstruktur mit zwei Feldern, die einen Schlüssel und einen Wert speichert. Wenn Sie eine spezielle Verarbeitung durchführen, mehr als zwei Felder speichern oder einen anderen Randfall haben, sollten Sie Ihre eigene Klasse erstellen. Andernfalls ist Map.Entry eine der am wenigsten genutzten Java-Klassen und eignet sich für solche Situationen.

0
ndm13

Ich weiß, dass dies zu spät ist, aber ich dachte, es wäre hilfreich für jemanden, der auf der Suche nach einer Antwort darauf ist. Sie können eine Bundle verwenden, um mehrere Datentypwerte zurückzugeben, ohne eine andere Methode zu erstellen. Ich habe es ausprobiert und funktionierte perfekt. 

In Your MainActivity, wo Sie die Methode aufrufen:

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

Methode:

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

P .: Ich bin nicht sicher, ob es in Ordnung ist, ein solches Bundle zu implementieren, aber für mich hat es perfekt funktioniert.

0
Dante