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

Von Java Klassen zum Java Programm – Der Programmstart

Java Klassen ausführen

In den letzten Beiträgen hast du gelernt, wie Java Klassen erstellt werden und aufgebaut sind. In diesem Beitrag geht es um den Programmstart. Ich will dir zeigen, was nötig ist, dass du ein Java Programm ausführen kannst. Und ich zeige dir außerdem, wie du eine Startklasse in einem x-beliebigen Javaprogramm anlegst. Wie auch schon zuvor, […]

Die sechs Bestandteile von Java Methoden

Java Methoden Bestandteile

Java Methoden hauchen deinem Java Programm Leben ein. Ohne eine Methode würde deine Java Klasse ein starres Konstrukt sein. Deine Objekte hätten Eigenschaften. Aber sie könnten nichts machen. Und das wäre eine trostlose Welt. Java Methoden sorgen also dafür, dass Objekte interagieren. Methoden bestehen aus bestimmten Bausteinen. Und diese Bausteine bestimmen, was die Methode darf […]

Java Übung 19 – Zähle die Kommastellen

Java Übung Kommastellen Zählen

In dieser Java Übung möchte ich, dass du eine Methode zum Zählen von Kommastellen schreibst. Lege dazu eine Klasse „KommaZahl“ an. Diese Klasse enthält die statische Methode „zaehleKommaStellen“, welche eine Kommazahl als übergebenen Parameter erwartet.

So kannst du deine Eclipse Oberfläche anpassen

Eclipse anpassen

In diesem Beitrag möchte ich dir zwei ganz nette Features von Eclipse vorstellen. Es geht um Views und um Perspektiven. Wie du schon weißt, besteht Eclipse aus einer grafischen Oberfläche. Und in dieser Oberfläche stehen dir verschiedene Views zur Verfügung. Was ist so ein View?

So lassen sich Java Strings in char zerlegen

Java Strings zerlegen char

Java Strings sind Zeichenketten. Und diese Zeichenketten lassen sich aufsplitten und in ihre Einzelteile zerlegen. Ich möchte dir in diesem Beitrag Möglichkeiten vorstellen, wie du Strings in Character-Datentypen zerlegen, extrahieren und die Einzelteile in Arrays speichern kannst.

So kannst du gelöschte Java Projekte oder Dateien in Eclipse wieder herstellen

Wahrscheinlich passiert es jedem einmal, dass man versehentlich Dateien löscht. Und dann? Die Wut ist riesig, weil man ja alles nochmal schreiben muss. In Eclipse hast du die Möglichkeit sämtliche Dateien wieder herzustellen. In diesem Beitrag möchte ich dir demonstrieren, wie du gelöschte Java Klassen, Dateien, Projekte oder Packages wieder herstellen kannst.

Java Übung: Alles beginnt mit Hello World

Java Übung Hello World

Alles beginnt mit „Hello World“. Sämtliche Java Bücher beginnen mit diesem ersten Beispiel. Auch die Java Übungen sollen mit diesem ersten Programm starten. Definiere eine Klasse „Hello World“. Implementiere die Main Methode. Die Main Methode soll bei Programmaufruf die Bildschirmanzeige „Hallo Welt“ zurückgeben. Die Lösung zur Java Übung „Hallo Welt“ public class HelloWorld{ public static […]

Java Strings landen im String Constant Pool

Java-Strings-Pool

Du kennst das. Es ist abends. Du sitzt gemütlich vor dem Fernseher. Das Smartphone bimmelt. Kein Anruf. Nein – Eine Nachricht. Du liest die Nachricht sofort und antwortest darauf. Minuten später bekommst du die nächste Nachricht. Und auch auf diese antwortest du. Im Laufe des Abends entsteht daraus eine nette kleine Konversation. Und eh du […]

Java Übung 25 – Simuliere eine Gelddruckmaschine

Java Übung Gelddruckmaschine

In dieser Java Übung geht es um Schleifen. Und zwar möchte ich, dass du eine virtuelle Geldruckmaschine erstellst. Was meine ich damit? Du gibst in der Konsole einen x-beliebigen Betrag ein und das Programm gibt dir virtuelle Geldscheine zurück. Ein Beispiel: Du gibst die Zahl 400 ein. Dann liefert dir das Programm 2 x 200 […]

So unterstützen dich Java Vererbungstabellen beim Entwurf

Java Vererbungstabellen

Bei der Java Vererbung gibt es zwei Klassenarten bzw. -stufen. Die Superklassen, welche einen allgemeinen Typen darstellen Und die spezielleren Unterklassen, welche die Superklasse um bestimmte Funktionen erweitern. Jetzt ist dieses ganze „Der-erbt-von-dem-Konzept“ mitunter sehr schwierig darzustellen. Zum Beispiel in einem Werkzeugkoffer. In einem Werkzeugkoffer befinden sich sämtliche Werkzeuge, von Säge bis Bohrmaschine. Wie machst […]