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.


Ähnliche Beiträge

Heap & Stack – Die Speicherverwaltung in Java

Java Speicher

Java nutzt eine interne Speicherverwaltung. Eigentlich sind es mehrere. Uns interessieren lediglich zwei. Da das Thema Speicherverwaltung recht umfangreich ist, habe ich dir im Folgenden einmal die wichtigsten Artikel zusammengestellt. Die zwei Speichersysteme von Java Java Methoden werden auf dem Stack gestapelt. Der Speicher auf dem Java Methoden zu Hause sind, nennt sich Stack Speicher. […]

So nutzt du getter und setter Methoden bei der Java Programmierung

Java Keyword private

In diesem Artikel möchte ich dir zeigen, wie du Instanzvariablen innerhalb der Java Klasse schützt. Und den Zugriff nur noch indirekt über getter und setter Methoden anbietest. Stell dir vor. Du hast ein Programm zur Lagerverwaltung geschrieben. Dieses Programm dient Möbelhäusern dazu, ihre Bestände zu verwalten. Und das Programm erwartet vom Nutzer gewisse Eingaben zu […]

Java lernen – 10 nützliche Tipps für Java Anfänger

Java Lernen Anfänger

Wenn du die Programmiersprache Java lernen möchtest, bist du hier prinzipiell erst einmal richtig. Und wenn du es wirklich ernst meinst und in die Java Programmierung einsteigen möchtest, solltest du auch meinen kostenlosen Java Kurs beanspruchen. Wenn du dabei bist, bekommst du: Eine Lektion pro Woche zu den Basics. Hier geht es um die ersten […]

Java lernen durch ständiges Testen – Nutze die Testumgebung von Eclipse

Java Programmierung lernen

Probieren geht über studieren Wenn du wirklich Java Programmierung lernen möchtest, dann solltest du Java nicht aus einem Buch lernen. Du solltest auch nicht strikt von dieser oder anderen Webseiten lernen. Etwas wirklich zu lernen, setzt die Bereitschaft voraus, etwas zu probieren. Denn nur durch eigenes Probieren gelangst du zum Wesentlichen. Durch Probieren wirst du […]

Das Instanzieren von Java Klassen verhindern

Java Objekte Instanzieren verhindern

Die Instanzierung von Java Klassen verhindern. Was heißt das? Instanzen sind die Objekte einer Java Klasse. Und Instanzieren oder Instanzierung heißt nichts anderes, als Objekterstellung. Aber was soll das? Oder mal anders gefragt: Wieso sollte man verhindern, dass eine Java Klasse – Objekte erstellen kann? Schließlich sind doch Objekte der Sinn und Zweck jeder objektorientierten […]

So kannst du mit dem StringTokenizer Java Strings zerlegen oder splitten

Java StringTokenizer Java Strings teilen zerlegen splitten

Java StringTokenizer – was ist das? Bevor ich diese Frage kläre, schiebe ich eine zweite Frage hinterher. Denn im Wort Tokenizer steckt das Wort Token. Also was ist ein Token? Hier die Definition zum Token: Ein Token ist eine bestimmte Aneinanderreihung von Zeichen. Man kann auch sagen, eine lexikalische Einheit. Das kann zum Beispiel eine […]

So kannst du Java Arrays anlegen

Java Arrays anlegen

Java Arrays– Was ist das? Stell es dir einmal als ein Bücherregal vor. In einem Bücherregal befinden sich sämtliche Bücher. Und diese befinden sich schön nebeneinander. Jedes Buch hat seinen festen Platz. Du kannst die Bücher ganz genau lokalisieren. Zum Beispiel kannst du sagen. Das erste Buch von links Das dritte von rechts usw. Und […]

Java Übung 27 – Auf zur Mathe-Olympiade

Java Übung Mathe Olympiade

In dieser Java Übung möchte ich mit dir ein Programm erstellen, welches ein Mathematik-Test oder eine Mathe-Olympiade simuliert. Du kennst das vielleicht noch aus der Schule. Matheolympiade- Da wurden aus allen vier Grundrechenarten, Aufgaben formuliert. Die Schüler mussten diese Aufgaben lösen. Die Lehrer kontrollierten die Lösungen. Und der Schüler, welcher die wenigsten Fehler hatte – […]

Ein Java Fenster erzeugen mit dem JFrame

Java-Fenster-erzeugen

Ein Java Fenster erzeugen mit Swing. Java Swing – was ist das? Zum Erstellen von grafischen Benutzeroberflächen, kurz GUI, bietet Java eine eigene Standardklasse an. Diese Klasse nennt sich Swing. Aus dieser Swing-Klasse heraus können Objekte erstellt werden. Diese Objekte lassen sich in vier verschiedene Kategorien einteilen. Fenster und Dialoge bilden das Grundgerüst einer grafischen […]