Skip to main content

Du bekommst was du vereinbarst – Die Rückgabewerte von Java Methoden

Was du vereinbarst, das bekommst du zurück.

Ach wäre es schön, wenn alles im Leben so funktionieren würde.
Aber zum Glück funktioniert dieses Prinzip bei deinen Java Methoden.

Denn du kannst den Rückgabetypen im Methodenkopf vereinbaren.

Doch bevor ich dir zeige, wie du den Rückgabetypen anlegen kannst….
Lass mich dir zeigen, wofür du den Kram eigentlich brauchst.

In deinem Java Programm hast du Methoden. Und diese Methoden sollen irgendetwas machen.
Und dann müssen die Methoden etwas zurück liefern.

Das kann ein Name sein.
Dies wäre dann ein Textwert.

Das kann aber auch eine Zahl sein.
Zum Beispiel ein Preis.

Jetzt lass uns ein paar Rückgabetypen festlegen.

Deine Java Methoden können jeden primitiven Datentypen zurückgeben

Bleiben wir beim Preis.

Ein Preis ist immer eine Zahl.
Somit ist der Datentyp entweder ein Double, ein Float, ein Integer usw.

Im Methodenkopf gibst du jetzt den Rückgabetypen an.


public class MethodenRueckgabe {
//Methode gibt eine ganze Zahl (int) zurück
public static int gibZurueck () {
return 2;
}
}

Lassen wir uns das Ergebnis direkt über die Konsole zurückgeben.
Du brauchst deshalb eine main Methode.
Und natürlich auch die System.out.println() Anweisung.


public class MethodenRueckgabe {
//Methode gibt eine ganze Zahl (int) zurück
public static int gibZurueck () {
return 2;
}

public static void main (String [] args){
//Die println Anweisung gibt jetzt das Ergebnis der Methode auf der Konsole aus.
System.out.println(gibZurueck ());
}
}

Schau dir die Methode genauer an.
Du siehst das Keyword return?

Die return Anweisung sagt jetzt deinem Java Programm:
„Hier bitte schön. Das ist der Rückgabewert“

Wichtig:
Die Methode bricht nach der return Anweisung ab.

Das bedeutet für dich:
Alles was du hinter dieser Anweisung einfügst, wird nicht mehr ausgeführt.

So geht’s nicht

public class MethodenRueckgabe {
//Die Methode bricht nach der return Anweisung ab
public static int gibZurueck () {
return 2;
System.out.println(4);
}

public static void main (String [] args){
//Beim Aufruf bleibt das Ergebnis unverändert
System.out.println(gibZurueck ());
}
}

Du kannst dir auch ein Ergebnis einer Gleichung zurückgeben lassen.


public class MethodenRueckgabe {
public static int gibErgebnisZurueck () {
return 2 * 8;
}

public static void main (String [] args){
System.out.println(gibErgebnisZurueck ());
}
}

In diesem Fall wird zuerst das Ergebnis der Gleichung berechnet.
Und erst dann wird dieses Ergebnis zurückgegeben.

Und natürlich kannst du nach dem gleichen Prinzip dir auch eine Kommazahl zurückgeben lassen.

Vereinbare im Methodenkopf ein Datentyp wie Double und los geht’s.


public class MethodenRueckgabe {
//Methode gibt eine Kommazahl (double) zurück
public static double gibKommazahlZurueck () {
return 2.223;
}

public static void main (String [] args){
System.out.println(gibKommazahlZurueck ());
}
}

Und natürlich funktioniert dies auch mit einem Character-Datentyp.

Lass uns jetzt zu den Wahrheitswerten kommen.

Und so kann deine Java Methode einen Wahrheitswert zurückgeben.

Wahrheitswerte sind entweder false oder true.

Damit deine Methode einen dieser Werte zurückgibt, vereinbarst du im Methodenkopf einen boolean Rückgabetypen.

Und dann kannst du mit den Wahrheitswerten spielen.
Du kannst dir einen fixen Wert zurück geben lassen.


public class MethodenRueckgabe {
//Die Methode gibt einen fixen Wahrheitswert zurück
public static boolean sageDieWahrheit () {
return false;
}

public static void main (String [] args){
System.out.println(sageDieWahrheit ());
}
}

Oder du verknüpfst zwei Werte mit einem logischen Operator.


public class MethodenRueckgabe {
//Die Methode wertet jetzt die Aussage aus und gibt diesen Ausdruck zurück
public static boolean sageDieWahrheit () {
return false || true;
}

public static void main (String [] args){
System.out.println(sageDieWahrheit ());
}
}

Du kannst natürlich deiner Methode auch Argumente übergeben und diese dann auswerten.


public class MethodenRueckgabe {
//Jetzt kannst du der Methode Argumente übergeben
public static boolean sageDieWahrheit (boolean a, boolean b) {
return a || b;
}

public static void main (String [] args){
//Beim Methodenaufruf werden die Argumente true und false übergeben
System.out.println(sageDieWahrheit (true, false));
}
}


Du kannst im Methodenrumpf auch andere Methoden aufrufen….

und dann den Rückgabewert weiter verarbeiten.

Zurück zum Preis.
Die folgende Methode soll den Gesamtpreis einer Warenlieferung zurückgeben.

Wir haben eine Anzahl an Waren
Und wir haben einen Stückpreis.

Beide Werte soll die Methode als Argument entgegennehmen und miteinander multiplizieren.

Als Ergebnis gibt sie dann den kompletten Warenpreis bzw. Warenwert zurück.

Was musst du jetzt machen?

  • Du schreibst eine Methode.
  • In der Parameterliste werden zwei Parameter vereinbart.
  • Parameter eins ist der Stückpreis. Es bietet sich an, den Datentyp double zu wählen.
  • Der zweite Parameter ist die Anzahl. Als Datentyp kannst du einen Integer wählen.

Was soll als Ergebnis zurückkommen?
Oder besser gefragt, welcher Datentyp kommt zurück?

Es macht Sinn, eine Kommazahl zu wählen.
Also vereinbare einen Double Datentypen im Methodenkopf.

Und so geht’s.


public class MethodenRueckgabe {
//Die Methode multipliziert die Werte und gibt das Ergebnis zurück
public static double berechneGesamtpreis (double stueckPreis, int stueckZahl) {
return stueckPreis * stueckZahl;
}

public static void main (String [] args){
//Beim Methodenaufruf wird die Anzahl und der Stückpreis übergeben
System.out.println(berechneGesamtpreis (22.19, 200));
}
}

Und natürlich kannst du diese Methode dann auch in den Methodenrumpf einer anderen Methode ausführen lassen.

Nehmen wir als weiteren Parameter einen Steuerschlüssel für die Umsatzsteuer auf.
Eine zweite Methode nimmt lediglich den Steuerschlüssel entgegen.
Und dann ruft diese zweite Methode die erste Methode auf.
Und jetzt wird die Steuer hinzuaddiert.

Und so sehen deine Java Methoden jetzt aus.


public class MethodenRueckgabe {
//Die Methode multipliziert die Werte und gibt das Ergebnis zurück
public static double berechneGesamtpreis (double stueckPreis, int stueckZahl) {
return stueckPreis * stueckZahl;
}

//Die Methode übergibt der Methode "berechneGesamtpreis" Standardwerte für Anzahl und Preis
public static double berechneBruttoGesamtpreis (double steuerSchluessel) {
return berechneGesamtpreis (100,10)*(1+steuerSchluessel);
}

public static void main (String [] args){
//Beim Methodenaufruf werden 19% Umsatzsteuer übergeben
System.out.println(berechneBruttoGesamtpreis (0.19));
}
}

Und du kannst das Ganze auch an eine Bedingung knüpfen.
Nehmen wir an:
Du gewährst deinem Kunden Rabatt.

Sobald die Anzahl über 1.000 Stück ist, gewährst du dem Kunden einen Rabatt von 2 Prozent.


public class MethodenRueckgabe {
//Die Methode prüft die Bedingung
public static double gibPreisNachlass (double stueckPreis, int stueckZahl) {
if (stueckZahl > 1000) {
return stueckPreis * stueckZahl - (stueckPreis * 0.02 * stueckZahl);
}
else{
return stueckPreis * stueckZahl;
}
}

public static void main (String [] args){
System.out.println(gibPreisNachlass (100, 10001));
}
}

Was passiert jetzt?
Die Methode prüft die Anzahl.
Wenn diese über 1.000 ist, dann springt die Methode in den if Block.
Falls die Anzahl allerdings unter oder gleich Eintausend ist, springt die Methode in den else Block.

Du siehst, es sind mehrere return-Anweisungen möglich.

Jetzt packen wir alles zusammen.

Du kannst es auch anders lösen.

So wird dein Programm flexibler.


public class MethodenRueckgabe {
//Die Methode prüft die Bedingung und ruft dann eine andere Methode auf
public static double berechneGesamtPreis (double stueckPreis, int stueckZahl) {
if (stueckZahl > 1000) {
return gibPreisNachlass(stueckPreis, stueckZahl );
}
else {
return stueckPreis * stueckZahl;
}
}

public static double gibPreisNachlass (double stueckPreis, int stueckZahl) {
return stueckPreis * stueckZahl - (stueckPreis * 0.02 * stueckZahl);
}

public static void main (String [] args){
System.out.println(berechneGesamtPreis (100, 10001));
}
}

Beim Programmstart werden der Methode „berechneGesamtPreis“ die Stückzahl und der Einzelpreis übergeben.

Die Methode „berechneGesamtPreis“ prüft die Stückzahl.
Falls die Stückzahl über 1.000 ist, gibt sie das Ergebnis aus der Methode „gibPreisNachlass“ zurück.
Dazu übergibt sie der Methode wieder die Stückzahl und den Stückpreis.

Falls die Stückzahl unter Eintausend ist, gibt die Methode den Wert aus dem else Block zurück.

Falls deine Methode keinen Wert zurückgeben soll, nutzt du das Keyword void.

Das letzte Programm kannst du auch anders schreiben.

Deine Java Methoden müssen nicht unbedingt etwas zurückgeben.
Die letzte Methode gibt einen Wert aus einer anderen Methode zurück.

Du kannst die Methode aber auch so gestalten:

  • Wenn der Wert über 1.000 ist,
  • Dann rufe die Methode „gibPreisNachlass“ auf.
  • Ansonsten rufe eine andere Methode auf.

Du siehst vorher haben wir uns Werte zurückgeben lassen.
Jetzt möchte ich, dass lediglich andere Methoden aufgerufen werden.

Und so würde dies aussehen:


public class MethodenRueckgabe {
//Die Methode prüft die Bedingung und ruft dann eine andere Methode auf
public static void berechneGesamtPreis (double stueckPreis, int stueckZahl) {
if (stueckZahl > 1000) {
System.out.println(gibPreisNachlass(stueckPreis, stueckZahl ));
}
else {
System.out.println(berechnePreis(stueckPreis, stueckZahl ));
}
}

public static double gibPreisNachlass (double stueckPreis, int stueckZahl) {
return stueckPreis * stueckZahl - (stueckPreis * 0.02 * stueckZahl);
}

public static double berechnePreis (double stueckPreis, int stueckZahl) {
return stueckPreis * stueckZahl;
}

public static void main (String [] args){
berechneGesamtPreis (100, 10001);
}
}

Im Methodenkopf steht anstelle eines spezifischen Rückgabe-Datentypen, das Keyword void.
Immer wenn du keinen Rückgabewert erwartest, schreibst du dieses Keyword in den Methodenkopf.

Im Methodenrumpf steht jetzt keine return-Anweisung mehr.
Logisch….du bekommst ja nichts zurück.

Dennoch kannst du die System.println() Anweisung einbinden.
Somit kannst du dir Werte auf der Konsole ausgeben lassen.
Mit diesen Konsolenwerten kannst du aber nicht weiter rechnen.


public class MethodenRueckgabe {
public static void berechneGesamtPreis (double stueckPreis, int stueckZahl) {
if (stueckZahl > 1000) {
System.out.println(gibPreisNachlass(stueckPreis, stueckZahl ));
}
else {
System.out.println(berechnePreis(stueckPreis, stueckZahl ));
}
}

public static double gibPreisNachlass (double stueckPreis, int stueckZahl) {
return stueckPreis * stueckZahl - (stueckPreis * 0.02 * stueckZahl);
}

public static double berechnePreis (double stueckPreis, int stueckZahl) {
return stueckPreis * stueckZahl;
}

public static void main (String [] args){
System.out.println (berechneGesamtPreis (100, 10001) * 2); //Das funktioniert nicht
System.out.println (berechnePreis (100, 10001) * 2);//Das funktioniert
}
}

Diese „void Methoden“ eignen sich eigentlich nur dazu, andere Methoden aufzurufen.
Mit den Werten der Rückgabe-Methoden kannst du weiter rechnen.

Zusammenfassung:

  • Wenn deine Methode etwas zurückgeben soll, musst du diesen Rückgabetypen im Methodenkopf vereinbaren.
  • Im Methodenrumpf muss dann die return Anweisung stehen.
  • Alles was hinter der return Anweisung steht, wird nicht mehr ausgeführt.
  • Falls du Java Methoden schreibst, welche nichts zurückgeben – Nutze das Keywort void.

Hat dir dieser Artikel gefallen?
Hast du Anmerkungen?
Hinterlasse mir doch einen Kommentar unter diesem Beitrag.