Rückgabe-Problem

Hallo Leute,
ich habe eine Methode, aus der ich 2 Strings zurückgeben will. Wie mache ich das?
Code:
static void createStrings() {
String a = scanner.nextLine();  //String 1
String b = scanner.nextLine(); //String 2
//Jetzt beide zurückgeben an die Main-Methode
}
 
Je nach dem was du machen willst:
- Strings zu einem String zusammenfügen
- ein String[] / List<String> zurückgeben
- eine eigene Klasse schreiben die die beiden Strings zu einem Objekt vereint

in jedem Fall musst du den Rückgabetyp deiner Methode ändern
 
Java:
return Array.asList(zeichenkette1, zeichenkette2);

MAIN:
String1 = rueckgabe.get(0);
String2 = rueckgabe.get(1);
Analog mit einem Array.

Auch möglich:

Definiere eine generische Klasse:

Java:
public final class GeordPaar<T> implements Serializable, Kopierbar<GeordPaar<T>> {
   
    private static final long serialVersionUID = 1L;
   
    private final T obj1;
    private final T obj2;

    public GeordPaar(T obj1_, T obj2_) {
        this.obj1 = obj1_;
        this.obj2 = obj2_;
    }

    @Override
    public int hashCode() {
        return obj1.hashCode() + obj2.hashCode();
    }

    @Override
    public boolean equals(Object anderes) {
        if (anderes == this) {
            return true;
        }
        if (!(anderes instanceof GeordPaar)) {
            return false;
        }

        GeordPaar<?> anderesGeordPaar = (GeordPaar<?>) anderes;
        return (obj1.equals(anderesGeordPaar.obj1) && obj2.equals(anderesGeordPaar.obj2));
    }
   
    @Override
    public String toString() {
        return "|("+obj1.toString()+", "+obj2.toString()+")|";
    }

    public T gibObj1() {
        return obj1;
    }

    public T gibObj2() {
        return obj2;
    }

    @Override
    public GeordPaar<T> gibKopie() {
        return new GeordPaar<T>(obj1, obj2);
    }
Entferne hierbei aber gibKopie() und die implementierte Schnittstelle Kopierbar.
 
Zuletzt bearbeitet:
Oder in einen String, musst dann nur sicherstellen, dass du immer weisst wie du ihn trennst.

zB:
Java:
... TRENNER = "[/}{]";

return string1 + TRENNER + string2;

// MAIN:
String[] array = rueckgabe.split(TRENNER);

String1 = array[0];
String2 = array[1];
Deine Strings sollten dann aber TRENNER nicht enthalten .

Und mach am besten noch length abfragen, ob es geklappt hat.
 
Zuletzt bearbeitet:
Es geht natürlich auch über öffentliche Klassenvariablen, das ist aber kein guter Stil.

Und, was auch zur Ergänzung von oben möglich ist:

Du kannst string1 und string2 verpacken lassen. Da musst du dann verpackermethoden implemetieren. Entsprechend auch Entpacker methoden. Damit kannst du dann an den Anfang von String1 und ans Ende etwas packen (das zb immer länger als String1 ist, kann man mit length() abfragen machen), analog bei String2. Die entpacker methoden entfernen das dann wieder.

Sowas wie:

Java:
rueck;
String1 = Entpacker.entpackeNr1(rueck);
String2 = Entpacker.entpackeNr2(rueck);
Damit müsstest du dann nicht mehr darauf achten, dass deine Strings TRENNER nicht enhalten, sondern du kannst beliebige nutzen. Aber schön ist das auch nicht.

Gib einfach einen Array zurück, ist wohl das einfachste.
 
Zuletzt bearbeitet:
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben