Methoden Verständnis

[Thomaskloea]

Guten Tag,

Mir fällt das grundsätzliche Vertändnis von Methoden noch schwer.

Ich beschreibe mal wie ich das sehe und vielleicht hilft/korrigiert jemand:
Die Methode geteilt(3/y, x++) wird aufgerufen, ergo werden die Parameter in die Methode geteilt übertragen und 3/y wird der Wert für int x und xüü wird der Wert für int y.

Soweit so richtig?

Jetzt wird in der geteilt Methode gerechnet: x=x/y

Also x = 3/y / x++ bzw. 3/2 / x++

Was passiert jetzt aber mit dem x++? Für die Berechnung des x in der Methode bleibt x=8 oder?

Also x = 3/2 / 8

Stimmt das? und dann wird der Wert x um eins erhöht? Also das Ergebnis aus der Rechnung davor eine Zeile hiervor oder meine gesetzte x variable die ich auch als Parameter übertragen habe?

Vielen lieben Dank!

public class Aufgabe {
public static void main(String[] args) {
int y = 2;
int x = 2 + 2 * y;
int ergebnis = geteilt(3 / y, x++) + geteilt(y + 1, 2);
System.out.println(x);
System.out.println(ergebnis);
}
public static int geteilt(int x, int y) {
x = x / y;
return x;
}
}

 

[kneitzel]

Also bei dem Aufruf wird der Parameter x auf 3/y gesetzt und der Parameter y bekommt x zugewiesen.

Generell sind die Parameter call by Value, d. h. die veränderten Werte wirken sich nicht auf die Parameter aus.

x++ bedeutet, dass erst x genommen wird. Wenn die eigentliche Operation fertig ist, wird x erhöht.
bei ++x wäre es umgekehrt. Da würde erst x erhöht und dann der Wert übergeben.
==> Das ist etwas, das man wissen sollte, aber so Code sollte man nie schreiben. Damit es gut lesbar ist, sollte man pro Zeile nicht mehrere Sachen machen. Also statt f(x++) schreibt man erst f(x) und dann x++ auf der zweiten Zeile.

 

[Thomaskloea]

Danke. Was x++ grundsätzlich bewirkt, ist mir verständlich.

Aber wann wird der x wert denn erhöht? Also die Rechnung in der geteilt Methode von x = x / y findet statt mit x = 3/2 / 8;
und dannach müsste x ja erhöht werden, richtig? Wird also dann das ergebnis der Rechnung um 1 erhöht?

 

[kneitzel]

Du wirfst einiges durcheinander! Einfach einmal den Code mit Kommentaren von mir - da verstehst Du hoffentlich, was abgeht:

public class Aufgabe {
public static void main(String[] args) {
int y = 2;  // lokale Variable y, wird auf 2 gesetzt. y := 2.
int x = 2 + 2 * y; // lokale Variable x - wird auf 6 gesetzt (2 + 2*2)! x := 6 (nicht 8!)

int ergebnis = geteilt(3 / y, x++) + geteilt(y + 1, 2);
// Hier wird jetzt ausgewertet von links nach rechts:
// -> ergebnis (3/2, 6) + geteilt(2+1, 2) sind die Aufrufe. Danach wird x erhöht.
// 3/2 = 1, 1/6 = 0 (Da Integer!), 3/2 = 1. 0+1 = 1 daher: ergebnis := 1
// Da x++ wird x noch erhöht, d.h. x:=7

System.out.println(x);  // 7
System.out.println(ergebnis); // 1
}
public static int geteilt(int x, int y) {
x = x / y;
return x;
}
}

 

[Thomaskloea]

Uff vielen Dank, das hilft sehr!

 

[Thomaskloea]

Wie kommst du auf die 1/6?

 

[mihe7]

Übergeben wird für x 3/2, also 1, und für y 6. In der Methode wird x/y, also 1/6, gerechnet.

 

[Thomaskloea]

achso, danke! Ich hatte es zuerst zusammengefasst.

Das return x liefert ja den x wert zurück in die Zeile mit dem int = Ergebnis, ja?

Wie kann ich aber nachvollziehen, dass das erhöhen von x um 1 wegen dem x++ zum Wert int x = 6 dazugezählt wird?

Das x++ ist doch nur ein Parameter, welcher in die Methode übertragen wird.

Oder besagt das x++ als Parameter in der Main, dass quasi zuerst das x normal in die methode übergeben wird und nach dem durchlaufen der Methode, wird int x um 1 erhöht?

 

[LimDul]

Was dir glaub ich im Verständnis fehlt - das x in der geteilt Methode hat gar nix mit dem x in der main Methode zu tun.

public class Aufgabe {
public static void main(String[] args) {
  int y = 2;
  int x = 2 + 2 * y;
  int ergebnis = geteilt(3 / y, x++) + geteilt(y + 1, 2);
  System.out.println(x);
  System.out.println(ergebnis);
}
public static int geteilt(int a, int b) {
  int c = a / b;
  return c;
}
}

Das heißt, vor dem ersten Aufruf von geteilt hat x den Wert 6 - danach den den Wert 7 - egal was in der geteilt Methode passiert (Exceptions mal ausgenommen - da wüsste ich gerade auch nicht 100% was passiert)

 

[mihe7]

Exceptions mal ausgenommen - da wüsste ich gerade auch nicht 100% was passiert

Nichts. Die Exception läuft ja vor der Zuweisung ab.

 

[kneitzel]

Egal was passiert. In Java ist alles Call By Value. Daher werden Werte vor dem Aufruf der Methode kopiert. Egal was in der Methode passiert: Der Inhalt der Variablen, aus denen die Werte kopiert wurden, ist immer unverändert. Auch bei Exceptions und so.

 

[mihe7]

Oder besagt das x++ als Parameter in der Main, dass quasi zuerst das x normal in die methode übergeben wird und nach dem durchlaufen der Methode, wird int x um 1 erhöht?

Richtig.
x++ = liefert den Wert von x vor dessen Erhöhung
++x = liefert den Wert von x nach dessen Erhöhung

D. h. würde man

int x = 10;
int y = x++;
int z = ++x;

ausführen, dann wäre y == 10 und z == 12.

 

[mihe7]

Vielleicht nochmal im Zusammenhang:

 1 public class Aufgabe {
 2     public static void main(String[] args) {
 3         int y = 2;
 4         int x = 2 + 2 * y;
 5         int ergebnis = geteilt(3 / y, x++) + geteilt(y + 1, 2);
 6         System.out.println(x);
 7         System.out.println(ergebnis);
 8     }
 9     public static int geteilt(int x, int y) {
10         x = x / y;
11         return x;
12     }
13 }

Wir rufen auf: java Aufgabe, d. h. die Java Virtual Machine wird gestartet und springt in die statische main-Methode der Klasse Aufgabe.

In Zeile 3 wird eine lokale Variable y vom Typ int deklariert und mit dem Wert 2 initialisiert.
In Zeile 4 wird eine lokale Variable x vom Typ int deklariert und mit dem Wert initialisiert, der sich durch den Ausdruck 2+2*y ergibt. Dazu wird zunächst 2*y berechnet (Punkt vor Strich), was 4 ergibt, anschließend wird 2+4 gerechnet, was insgesamt 6 ergibt. Die 6 wird abschließend der Variablen x zugewiesen.

In Zeile 5 wird eine lokale Variable ergebnis vom Typ int deklariert und mit dem Wert initialisiert, der sich durch den Ausdruck geteilt(3/y, x++) + geteilt(y+1,2) ergibt.

Bevor die Addition durchgeführt werden kann, müssen die Werte der Teilausdrücke berechnet werden, d. h. geteilt(3/y, x++) und geteilt(y+1,2) - und zwar in der Reihenfolge (grundsätzlich von links nach rechts).

Also wird erstmal geteilt(3/y, x++) berechnet. Hier gibt es wieder zwei Teilausdrücke, nämlich 3/y und x++. Dabei wird 3/y zu 3/2, was - wegen ganzzahliger Division - 1 ergibt. Für das x++ wird x verwendet (gleichzeitig wird x erhöht).

D. h. geteilt(3/y, x++) wird zu geteilt(1, 6). Die beiden Werte werden nun als Kopie an geteilt übergeben.

Die Methode geteilt hat zwei Parameter x und y, die haben mit den Variablen aus main nichts zu tun, auch wenn ihre Namen gleich lauten. Vielmehr werden diese Parameter bei jedem Aufruf als eine Art lokaler Variablen der Methode geteilt eingerichtet.

In Zeile 10 wird nun x/y berechnet, also 1/6 und das Ergebnis (0) der lokalen Variablen x zugewiesen. In Zeile 11 wird der Wert der lokalen Variablen zurückgegeben.

Zu dem Zeitpunkt haben wir in Zeile 5: 0 + geteilt(y+1,2). Bevor wir die Addition durchführen können, müssen wir wissen, was geteilt(y+1, 2) ergibt. Gleiches Spiel wie vorhin: wir haben zwei Teilausdrücke, nämlich y+1 und 2. Die werden ausgewertet, so dass geteilt(3, 2) aufgerufen wird.

In Zeile 10 wird wieder x/y berechnet, also 3/2 und das Ergebnis (1) der lokalen Variablen x zugewiesen. In Zeile 11 wird der Wert der lokalen Variablen zurückgegeben.

Zu dem Zeitpunkt haben wir in Zeile 5: 0 + 1 stehen. Jetzt kann die Addition durchgeführt und der Variablen ergebnis zugewiesen werden.

In Zeile 6 wird nun x (lokale Variable der Methode main) ausgegeben. Die wurde zuvor um 1 erhöht (x++), so dass deren Wert nun 7 ist.

In Zeile 7 wird abschließend noch der Wert von ergebnis, also 1, ausgegeben.

Ich hoffe, mich nirgends verhauen zu haben 🙂

 

[Xyz1]

Die wurde zuvor um 1 erhöht (x++), so dass deren Wert nun 7 ist.

Die wird doch erst hinterher erhöht. 😉

 

[kneitzel]

Die wird doch erst hinterher erhöht. 😉

Wieso? Aus Sichtweise der Zeile 6 ist das richtig. Die Variable x wird vor der Ausgabe noch um 1 erhöht, denn das ist ja noch von der Ausführung übrig geblieben.