Java Grundlagen

[BloodRocks]

Wenn eine Methode den Rückgabewert 3 hat und diese Methode 3 mal durchgeführt wird, wird dann insgesamt der Wert 9 zurück gegeben und in der Methode gespeichert?

 

[Crumar]

Wenn Sie nur das literal 3 zurückgibt, nicht. Möglich ist es aber. Generell sind code Beispiele hilfreich.
In einer Methode wird aber generell nichts gespeichert, nur in Variablen

 

[BloodRocks]

Ich verstehe das Prinzip der Rückgabe nicht ganz. Wenn ein Wert zurück gegeben wird, wird es dann in der Methode gespeichert? Ist dann die Methode so etwas wie eine Variable?

 

[Crumar]

Vielleicht schreibst du mal die Methode dazu, sonst kann man dir das nicht wirklich beantworten
Grundsätzlich wird der Wert zurückgegeben und der Aufrufer macht damit, was er damit machen möchte

 

[madmax2010]

Rückgabe ist das was du 'ausgibst' nachdem die Methode aufgerufen wurde.
Bspw:
sum(int X, int Y) {
return( X+Y)
}

Die Methode sum nimmt X und y als Eingabe und gibt ihre Summe aus
(sorry von 1 Formatierung her, bin auf dem Rad)

Sonst Zeig mal ein Code Beispiel was dir Probleme macht.

 

[G-Red]

In Anlehnung an den Beispiel von @madmax2010

get_sum (int x, int y){
    return(x+y); //Rückgabewert der Funktion
}

my_funktion(){
int result, a, b;

a = 1;
b = 2;

result = get_sum(a,b); //Aufruf der Funktion, die nur das Ergebnis zurückliefert
print result;
}

 

[Wasserhuhn]

Für die Speicherung bist du verantwortlich.
Stelle dir die Methode als Ballschießgerät vor. Die Parameter sind Flugwinkel und Geschwindigkeit. Den Ball/Rückgabewert darfst du fangen/speichern.

 

[G-Red]

Für die Speicherung bist du verantwortlich.
Stelle dir die Methode als Ballschießgerät vor. Die Parameter sind Flugwinkel und Geschwindigkeit. Den Ball/Rückgabewert darfst du fangen/speichern.

Oder noch plastischer
Colla-Automat in den man nen Euro (dein Parameter) rein wirft und als Ergebnis kommt die Dose raus die du nehmen kannst.

 

[michi.o]

Eine Methode ist ein Unterprogramm. Es ist einfach ein Block aus Code, der beim Aufruf der Methode ausgeführt wird. Was von der Methode zurück kommt hängt davon ab, was in der Zeile mit dem "return" steht.

 

[Raijin]

Eine Methode gibt das zurück was du ihr einprogrammiert hast. Weder kann man pauschal sagen, dass sie - wie in deinem Beispiel - immer 3 zurückgibt noch, dass die bei jedem Mal 3 auf den Rückgabewert oben draufpackt. Der Rückgabewert ist das was als Resultat aus dem Quellcode der Methode entsteht.

Prinzipiell ist eine Methode nur wiederverwendbarer Code. Sie erfüllt eine Aufgabe, die mit oder auch ohne Übergabeparametern irgendetwas tut und im Rückgabewert das Ergebis zurückgibt.

Dss oben formulierte Beispiel einer Methode gibt beispielsweise immer die Summe der Übergabeparameter zurück. 2, 3 = 5. Bei jedem Aufruf mit (2, 3) oder auch (3, 2) wird der Rückgabewert 5 lauten, bei (1000, 1000) wäre er aber 2000, auch wenn du das 17.156 Mal hintereinander aufrufst.

Soll eine Methode in sich selbst einen Wert speichern, der zukünftige Aufrufe beeinflusst, muss dieser entweder in einer statischen Variable oder einer übergeordneten Variable - zB Membervariable der Klasse - gespeichert werden, um anschließend im Code der Methode in irgendeiner Form zur Berechnung des Rückgabewerts herangezogen zu werden.

 

[Wasserhuhn]

Colla-Automat

...
Aqua...

 

[BloodRocks]

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 ());
}
}

Jetzt ist die Frage : Was bringt das überhaupt, denn warum schreibt man nicht einfach
gibZurueck = 2.
Also, was hat das für einen Sinn?

 

[madmax2010]

public class MethodenRueckgabe {

    public static void main (String [] args){
        System.out.println(gibZurueck ());
    }
   
    public static int gibZurueck () {
        return 2;
    }
}

ich war mal so frei.

Der Sinn der Aufgabe ist vermutlich, dass dir klar wird was wie und in welcher Reihenfolge aufgerufen wird.
Untern mal ein paar alternativen (kleine fehler werden vorhanden sein - ist jahre her das ich aktiv mit Java gearbeitet habe.
Es gibt massig wege die Ziffer 2 auszugeben.

// hier ist die Ausgabe in der Methode ohne rueckgabe
public static void main (String [] args){
    gibZurueck();
}

public static void gibZurueck () {
    System.out.println('2');
}
//
//
//
// ODER einfach direkt ausgeben
public static void main (String [] args){
    System.out.println('2');
}
//
//
//
// ODER  Erst einer variablen zuweisen und dann deren Inhalt wiedergeben
public static void main (String [] args){
    x = gibZurueck();
    System.out.println(x);
}

public static int gibZurueck () {
    return 2;
}

Die 3 machen alle das gleiche, nur halt anders formuliert

 

[Raijin]

Was bringt das überhaupt, denn warum schreibt man nicht einfach
gibZurueck = 2

Eine Methode kann beliebig komplex sein. Je simpler sie ist - zB ein banales return mit einer statischen 2 - umso geringer ist offensichtlich der Vorteil der Kapselung. Aber dieses Beispiel ist natürlich auch relativ sinnfrei, weil "return 2" inkl. Methodenkopf unfassbar viel aufwendiger ist als einfach nur eine .. .. .. 2.

Es geht bei Methoden primär darum, wiederkehrende Teilaufgaben zu kapseln. Aufwändige Berechnungen oder sonstige Vorgänge, die an zentraler Stelle - in der Methode - ausprogrammiert werden, um sie anschließend an beliebig vielen Stellen mit einer einzigen Zeile abrufen zu können. Besser noch: Sollte man etwas an der Berechnung ändern wollen, muss man es nur in der Methode tun und nicht an den Aufrufstellen, sofern man nichts an den Über- bzw Rückgabeparametern ändert.

 

[DeepComputer]

Ich verstehe das Prinzip der Rückgabe nicht ganz. Wenn ein Wert zurück gegeben wird, wird es dann in der Methode gespeichert? Ist dann die Methode so etwas wie eine Variable?

Hallo,

naja... eine Methode ist keine Variable, weil sie ihren Rückgabewert nicht speichert, sondern bei jedem Aufruf neu berechnen muss.
Variablen werden deklariert und initialisiert, Methoden sind nur "Funktionen" die mit Variablen operieren. Also diese zusammen zählen, sortieren, verändern, usw. Sie haben einen fixen Rückgabetyp (aber keinen fixen Rückgabewert!). Sie können vom Typ string, int, float, double, int[], char[] usw sein. Der Typ "void" gibt "nichts" zurück. "void Methoden" kannst du nichts als Argumente verwenden, weil es zB keine Variable vom typ void gibt.

Wichtig ist zu wissen, dass eine Methode vom Typ "int" nur einen Rückgabewert vom Typ "int" akzeptiert, diesen aber nicht speichert.
Du kannst diesen Wert aber trotzdem dadurch verwenden, indem du die Methode in einer anderen Methode verwendest, deren Argumente vom Typ "int" sind.

 

[BloodRocks]

OK, danke für eure Antworten. Hat mir echt sehr geholfen.

 

[BloodRocks]

 public class Vehicle {
    private String color;
    
    // Getter
    public String getColor() {
        return color;
    }
    
    // Setter
    public void setColor(String c) {
        this.color = c;
    }
}

class Program {
    public static void main(String[ ] args) {
        Vehicle v1 = new Vehicle();
        v1.setColor("Red");
        System.out.println(v1.getColor());
    }
}

Ich verstehe nicht, für was diese "getters" und "setters" gut sein sollen. Also was bewirken diese? D. H. Was haben sie für eine Funktion?

 

[Mystery1988]

Du erstellt ein Objekt vom Typ Vehicle mit der Eigenschaft Color.
Um auf die Farbe dieses Objektes zuzugreifen können brauchst du ein getter und um es zu setzen setter.

Man könnte jetzt Vehicle noch um dem String Antriebsart erweitern und dazu ein getter und setter erstellen.

Du erstellt in Zeile 17 das Objekt und in Zeile 18 setzt du das.
Wenn du das erweitert hast könntest du dann sagen v1.setAntriebsart("Front"):
Wenn du später die Antriebsart wissen willst dann musst du nur sagen v1.getAntriebsart();

 

[DeepComputer]

Hey
public class Vehicle //du erstellst hier ein (Klassen)-Objekt "Fahrzeug".

    public String getColor() {
        return color;
    }

Mit diesem "getter" kannst du die Eigenschaften des Fahrzeugs abfragen. Color ist eine string Variable, die die Farbe des Fahrzeugs speichert oder "in sich trägt". "return color" übergibt den Wert der Farbe der Methode "public String getColor". Bevor du also jedesmal die Farbe irgendwie suchen musst fragst du sie einfach mit der Funktion getColor(); ab.

    // Setter
    public void setColor(String c) {
        this.color = c;
    }

Der Setter setzt die Farbe des "Objekts", in deinem Fall des Klassenobjekts Fahrzeug. Das tut er indem er durch das Keyword "this" das Argument der Funktion setColor(string c), also den "string c", in die "private Variable c" schreibt.

        Vehicle v1 = new Vehicle();
        v1.setColor("Red");
        System.out.println(v1.getColor());

Hier erstellst du in der ersten Zeile ein neues (Kalssen)Objekt Fahrzeug mit dem Namen v1.
mit v1.setColor("Red") übergibst du deinem Fahrzeug das Argument "Red", welches dann durch die setColor() Methode in die private Variable "private string color" gespeichert wird. Jetzt hat dein Fahrzeug die Farbe "Red" in sich gespeichert.
Du könntest jetzt auch ein zweites Objekt erstellen mit

        Vehicle v2 = new Vehicle();
        v2.setColor("Blue");
        System.out.println(v2.getColor());

Jetzt kannst du besser sehen, dass v1.setColor und v2.setColor zwei verschiedene Fahrzeuge sind, die sich anhand ihrer Farbe (private string c) unterscheiden. v1.getColor und v2.getColor gibt jeweils die Farbe des Fahrzeugs v1 oder v2 zurück.

Alles klar?

Ergänzung (3. November 2021)

Was vllt verwirrt ist, dass der setter eigentlich nicht wirklich etwas "setzt", sondern nur etwas übergibt. Du setzst die Farbe in der Main Funktion indem du sie als Argument an die setColor Methode übergibst.
Getter und Setter sind "Zugriffsfunktionen", mit denen du Werte einer Klasse auch von außerhalb der Klasse, also zB aus der main Methode, verändern oder abfragen kannst.

 

[Raijin]

Entscheidend bei Gettern und Settern ist, dass man den Zugriff auf die zugrundeliegende Membervariable des Objekts steuern kann. Das heißt, dass ein Benutzer dieses Objekts nicht direkt die Membervariable ändert, sondern die Änderungsfunktion (Setter) aufruft oder eben die Abruffunktion (Getter).

Nu kann man sich natürlich fragen was denn so schlimm daran ist, direkt auf die Membervariable zuzugreifen. Der Grund dafür ist schnell erklärt: Eine Klasse bzw. das Objekt kennt ja unter Umständen bestimmte Situationen, in denen der Wert der Variable vielleicht gar nicht geändert werden darf! Oder aber der zu setzende Wert muss zuvor auf Plausibilität geprüft werden. Was ist damit gemeint? Simples Beispiel:

Vehicle v1 = new Vehicle();
v1.setColor("Blue");
// Farbe des Fahrzeugs = blau, alles gut

Vehicle v2 = new Vehicle();
v2.setColor("Walter");
// Farbe des Fahrzeugs = .. .. .. Walter?!? What?!?

Der Setter könnte beispielsweise den Input gegen eine Liste von zugelassenen Farben prüfen, zB "Red", "Green", "Blue". Wird etwas anderes eingegeben, ändert der Setter die Variable nicht.

public void setColor (string c)
{
   // Setter prüfe in einem Switch-Statement ob c zugelassen ist
   switch(c.ToUpperCase())
   {
      case "RED":
      case "GREEN":
      case "BLUE":
         this.color = c;
         break;
      default:
         break;
   }
}

Ein anderes Beispiel wäre, wenn die Farbe vielleicht gar nicht als Text, sondern als RGB-Code gespeichert werden soll. Statt "Red" könnte der Setter beispielsweise "#FF0000" in der Membervariablen speichern.




Bei Minimalbeispielen merkt man den Vorteil natürlich nicht so sehr und man kann sich fragen wozu das überhaupt sinnvoll sein sollte, weil es überflüssig kompliziert aussehen mag, wenn einfach nur return variable bzw. variable=input im Getter/Setter steht. Es geht dabei aber um den potentiellen Nutzen, wenn Getter und Setter eben tatsächlich etwas tun sollen, außer die Variable 1:1 zu lesen und zu schreiben.