# return



## wee witch (10. Aug 2010)

Hallo,

ich hoffe ihr könnt mir hier helfen 
Ich bin grad dabei Java zu lernen und komme mit den Erklärungen in meinem Buch net ganz so zurecht.

Ich arbeite mich grade durch die Methoden, die ich gut verstehe und returns, die ich nicht so ganz verstehe.
Es steht ständig im Buch return gibt einen Wert zurück. Wohin zurück? Ich schreibe die Beispiel-Codes aus dem Buch immer ab, um es besser zu verstehen und es mir einzuprägen, aber bei return-anweisungen häng ich.

zb. in der methode Rational


```
class Rational
{
.....

double getReal()
{
     return ((double)num)/denom;
}
...
void output()
{
System.out.println(getReal());
}
}
```

wozu so kompliziert? ich könnte doch auch einfach im hauptprogramm schreiben:


```
double ergebnis = ((double)num) /denom;
System.out.println(ergebnis);
```

mir fehlt einfach der sinn hinter dem return-befehl.
ich hoffe, mir kann das jemand erklären. 

lg
wee witch


----------



## Sonecc (10. Aug 2010)

Du stellst da grade nicht return in Frage, sondern Methoden an sich.
Durch Methoden kannst du bestimmte Funktionen an mehreren Stellen deines Programmes nutzen.
Statt sie dann jedes mal neu schreiben zu müssen, rufst du einfach deine Methode auf und hast damit arbeit gespart.

Was dein Problem mit return betrifft.
Return gibt dem Aufrufer die entsprechenden Daten.
In deinem Fall erhält also System.out.println() das Ergebnis von getReal()



> methode Rational



Klasse, nicht Methode


----------



## Jango (10. Aug 2010)

Return gibt immer einen Wert zurück, den der Aufrufer erwartet und verarbeitet.
Man kann eine Methode auch aufrufen ohne einen return-wert - nur halt, um irgendwas zu machen, was später nicht mehr relevant ist.
Return bedeutet auch das Ende einer Methode.


----------



## MAltendeitering (10. Aug 2010)

Ich kann mich Sonecc nur anschließen, das Beispiel, das du hast ist natürlich nur exemplarisch und an dieser Stelle ist eine Methode mit Rückgabewert nicht unbedingt nötig oder sinnvoll. Aber bei größeren, komplexeren Projekten werden die Rückgabewerte essentiell und kannst und willst nicht mehr darauf verzichten.



> Es steht ständig im Buch return gibt einen Wert zurück. Wohin zurück?


immer an die Stelle deines Programms, an der du die Methode aufgerufen hast.


----------



## wee witch (10. Aug 2010)

ja, ich versteh euch schon. mein problem ist eher:

wozu der returnbefehl, wenn es doch durch das

void output() eh schon da steht.

ist das nicht doppelt-gemoppelt?


----------



## Zacherl (10. Aug 2010)

Naja, du kannst ja innerhalb der Methode wieder verzweigen (mit einer if-else-Anweisung) und dann beispielsweise im einen Fall Wert A zurückgeben und im anderen Wert B. Das return kennzeichnet also gleichzeitig den Ausstiegspunkt der Methode und die Variable oder Konstante, welche hinter dem Wert steht, wird zurückgegeben.

Falls es eine Funktion ohne Rückgabewert ist (also void), so wird return nur zum vorzeitigen Verlassen der Methode verwendet, sprich der folgende Code wird nicht ausgeführt, und keine Variable/Konstante dahinter gestellt (-> einfach nur "return;").

Beispiel:


```
void tuwas() {
    if (dastimmtwasnicht) return; //abbrechen
    else {
          ...
    }
}
```


----------



## wee witch (10. Aug 2010)

jo, aber wenn ich mir das ergebnis anzeigen lassen will, brauch ich so oder so einen output. macht das, das return nicht überflüssig? weil return gibt ja nur dem programm einen wert, der dann halt da ist, aber mehr auch nicht.


----------



## wee witch (10. Aug 2010)

ich glaub, ich steh grad derbe auf dem schlauch^^


----------



## Tomate_Salat (10. Aug 2010)

In den meisten fällen, willst du das Ergebnis aber nicht ausgeben, sondern übergibst einfach nur eine zwischenlösung oder private Elemente.


----------



## Zacherl (10. Aug 2010)

Was verstehst du unter Output? Die Sache ist doch die, du musst in der Funktion irgendwie sagen, was sie zurückgeben soll, wenn sie nicht gerade void als Rückgabetyp hat - und wie willst du das ohne return machen? Dafür ist das gerade da.

Edit: Jap, das mit dem Output habe ich missverstanden - aber nimm einfach mal an, du willst eine Funktion zur Berechnung eines Wertes benutzen. Die Ausgabe kannst du aber auf verschiedenen Wegen realisieren, beispielsweise kannst du das in eine Datei schreiben oder auf die Konsole oder... und der Punkt ist: Wenn du die Funktion nutzt, die den Wert zurückgibt, dann kannst du die gleiche Funktion für jedes Ausgabemedium benutzen, obs jetzt die Konsole oder ne Datei ist, und brauchst das nicht immer neu zu schreiben.


----------



## wee witch (10. Aug 2010)

ich fange langsam an zu begreifen, ich glaube ich habe mich am buchbeispiel einfach festgefahren gedanklich. 
hast du vielleicht ein ganz kurzes code-beispiel für mich? ich tu mir ansich leichter wenn ich es sehe. nur im buch, mit dem ich arbeite, ist sein 30 seiten ein und das selbe beispiel an dem rumgeprockelt wird... ich steig da nimma durch.^^


----------



## ARadauer (10. Aug 2010)

> wozu so kompliziert? ich könnte doch auch einfach im hauptprogramm schreiben:


ganz einfache überlegung... stell dir vor dein hauptprogramm  195.000 Zeilen Code...


----------



## wee witch (10. Aug 2010)

jaja, verstehe.. warum einfach, wenns auch kompliziert geht^^

mir ist klar, dass return sinn macht, nur da ich grad wirklich arg auf dem schlauch stehe, fehlt mir die erkenntnis des sinns^^


----------



## Tomate_Salat (10. Aug 2010)

```
public class DemoExampel
{
	private	int	   call;
	private String id;
	
	public DemoExampel(String elementId)
	{
		id	= elementId;
		call= 1;
	}
	
	/**
	 * Gibt true zurück bei erfolgreicher wertübername
	 * 
	 * @param newCall
	 * @return
	 */
	public boolean setCall(int newCall)
	{
		if(newCall == 0)
			return false;

		call  = newCall;
		
		return true;
	}
	
	private String getElementId()
	{
		return id;
	}
	
	public boolean compareId(String otherId)
	{
		return id.equals(otherId);
	}
}
```

Hier hast du ein paar gängige Beispiele: 

return-wert verwenden um anzugeben, ob eine wertänderung erfolgreich war(setCall) [+Extra: den zu setzenden wert erst überprüfen, bevor er gespeichert wird]
Um nur Lese-Zugriff auf ein Element zu bekommen (getElementId (wird hier im konstruktor gestzt))
um zu prüfen, ob werte übereinstimmen(compareId) 

MFG

Tomate_Salat


----------



## Zacherl (10. Aug 2010)

Okay, dann was einfaches:


```
public class Return {
	
	public static void main(String[] args) {
		System.out.println(hello()); //Ausgabe auf die Standard-Konsole
		System.err.println(hello()); //Ausgabe auf die Error-Konsole
		
		//Alternative:
		String resultA;
		//Hier muss jetzt einmal das Komplizierte gemacht werden.
		resultA = "Hello World";
		System.out.println(resultA);
		
		String resultB;
		//Hier muss das Komplizierte nochmal gemacht werden.
		resultB = "Hello World";
		System.err.println(resultB);
	}
	
	public static String hello() {
		//Hier könnte auch was viiiiieeeeeeeel Komplizierteres stehen,
		//das den Return-Wert - das "Hello World" - zusammensetzt.
		return "Hello World";
	}
	
}
```

Hier erscheint dir das vielleicht wieder überflüssig, weil man für die Alternative einfach resultA für beides nehmen könnte (steht ja direkt hintereinander).

Aber jetzt stell dir mal vor, du befindest dich an ner total anderen Stelle von deinem Programm (z. B. du hast nen Editor, bei der einen Sache willst du den im Editor gerade bearbeiteten Text zur Anzeige auf den Bildschirm übertragen, bei der anderen Sache willst das in eine Datei abspeichern) - wie du an den Text kommst, dafür kannst du eine Methode nutzen, die den Text über "return" zurückgibt und die du sowohl für das Speichern als auch für die Bildschirmausgabe verwendest; du musst später also nur den Teil neu programmieren, der zur Ausgabe (auf den Schirm/in die Datei) verwendet wird und der sich unterscheidet.


----------



## StrikeTom (10. Aug 2010)

```
public class Klasse
{
     private String string;
     public Klasse(String string)
     {
           this.string = string;
     }
     public String getString()
     {
           return string;
     }
     public void setString(String string)
     {
           this.string = string;
     }
public static void main(String[]args)
{
    Klasse klasse = new Klasse("String1");
    System.out.println(klasse.getString());
    Klasse.setString("String2");
    String sinnlos = klasse.getString();
    System.out.println(sinnlos);
}
}
```
Verdeutlichung von return


----------



## wee witch (10. Aug 2010)

setCall und isId verstehe ich gut. danke schön, 

was mir jetzt noch net klar ist, wie kann ich mir das dann anzeigen lassen?  println(return) wird ja nicht funzen.

ich weiß, in komplexen programmen geht es nicht darum, sich jeden fuzzel ausgeben zu lassen, aber ich bin halt wirklich noch sehr am anfang und kontrolliere so was ich da zusammengetippselt habe.


----------



## wee witch (10. Aug 2010)

@ StrikeTom : Danke, bissi viele String aber ich denke ich habs.^^
@ Zacherl: Tausend Dank, bei deinem Code is grad der Knoten im Schlach geplatzt!!!! Mein Tag wird wieder schön


----------



## Landei (10. Aug 2010)

Wobei dein Schlauch nicht ganz von der Hand zu weisen ist: In vielen Sprachen wird einfach der letzte Wert in der Methode zurückgegeben (manchmal hat man trotzdem ein return, um die Methode in der Mitte beenden zu können), was ja auch ein sinnvolles "Default-Verhalten" ist. Java erfordert allerdings immer ein return, es sei denn die Methode gibt nichts zurück (void).

Methoden sind prinzipell dazu da, die Arbeit in die kleinsten logisch sinnvollen Bestandteile aufteilen zu können, einfach weil sich dadurch alles einfacher nach Bedarf "zusammenstecken" läßt. Etwas zu berechnen und etwas auf der Konsole auszugeben sind bereits zwei Aufgaben, also sollte das auch in zwei Methoden aufgeteilt werden: Was nützt dir z.B. eine Quadratfunktion, die ihr Ergebnis auf der Konsole ausgibt, wenn du sie eigentlich für die Berechnung der Distanz (wurzel(quadrat(abstandX) + quadrat(abstandY)) benötigst?

Man kann diese "Aufgabenverteilung" in verschiedene Methoden auch als Unterfall des Separation of Concerns-Prinzips ansehen.


----------



## Marco13 (10. Aug 2010)

Jetzt sowas wie Rekursion zu erwähnen würde wohl bestenfalls zur "Akzeptanz", aber nicht unbedingt zum Verständnis beitragen  Aber vielleicht ist ja weder ersteres noch letzteres überhaupt noch notwendig.


----------

