Wert von Variablen

[Hunter12]

Hallo,
ich bin neu hier und habe bzw. lerne karelJ ne Java Vereinfachung. Gerade habe ich mir folgende Aufgabe mit Lösung angeschaut:

Betrachten Sie das folgende Programm genau. Nehmen sie an, dass mit Tester test = new Tester
(42, 23); eine Instanz dieser Klasse angelegt wird und anschließend mit test.m(); aufgerufen wird.
Welchen Wert haben die einzelnen Attribute von test nach dem Ende des Aufrufs?

class Tester {
 int x, y, z;
 Tester(int a, int z) {
      x = a;
      y = z;
      z = x + y;
 }
 void m() {
     int v = 19;
     int w = 19;
     int x = 19;
     v = f(3) * z;
     w = y / x - f(f(z + x));
     x = x + f(y);
     y = x - v;
     z = f(v) - f(w) + f(z);
}

 int f(int x) {
     return z / y + x;
 }
}

Man soll sagen welchen Wert die Variablen x, y und z haben. Laut Lösung, in der leider keine Erklärung steht, erhält man folgende Werte:
x = 42
y = 42
z = 18

ich versteh leider nicht wie diese Werte zustande kommen und man genau diese Werte erhält :-(
Es wäre nett wenn mir das jemand erklären kann.
Danke schonmal.

 

[Hunter12]

class Tester {
  int x, y, z;
  Tester(int a, int z) {
     x = a;
     y = z;
     z = x + y;
  }
  void m() {
     int v = 19;
     int w = 19;
     int x = 19;
     v = f(3) * z;
     w = y / x - f(f(z + x));
     x = x + f(y);
     y = x - v;
    z = f(v) - f(w) + f(z);
  }

  int f(int x) {
     return z / y + x;
   }
}

 

[HimBromBeere]

Fangen wir mal an: den Ausruck

Tester test = new Tester(42, 24);

nennt man Variablendeklaration (mit Initialisierung). D.h. es wird wie in der Aufgabe beschrieben eine neue Variable test vom Typ Tester angelegt, welcher die beiden Werte 42 und 23 übergeben werden. Schauen wir uns den zugehörigen Konstruktoraufruf (so heißt dann die "Methode", die ausgeführt wird, wenn du eine neue Instanz erstellst) an, so finden wir

Tester(int a, int z){...}

.
Hier wird dem Programm mitgeteilt, dass zwei Integer-Eingangsparameter benötigt werden, um ein solches Objekt erstellen zu können (in deinem Fall also 42 und 23). Diese werden werden anschließend in der Instanz selbst gespeichert iin sog. Instanzvariablen, also Variablen, die genau zu diesem einen Objekt gehören und innerhalb dieses Objektes überall sichtbar sind. Daher kann in anderen Funktionen, die die Klasse Tester bereitstell, auf diese Werte zugegriffen werden.

Am Bsp.:

Tester test = new Tester(42, 24);

-->erzeugt neues Objekt mit x = 42, y = 23, z = 42 + 23 = 65

test.m()

-->ruft eine Berechnungsfunktion auf:

f(3) = z / y +x = 65 / 42 + 23 = 24 (da Ganzzahloperation)

v (in der Funktion m()) wird demnach f(3) * 3 also 72 sein
w = y / x - f(f(z + x)) = 23 / 42 - f(f(65 + 42)) = 0 - f(f(117) = -f(46)

Meine Güte, langsam wird´s aufwendig.
So, weiter:

EDIT: Mir reicht´s, ich denke, da ich wahrscheinlich eh irgendwo ´n paar Flüchtigkeitsfehler drin habe, wirst du besser kommen, du setzt in deinem Programm einfach ein paar Haltepunkte und ziehst den Debugger zu Rate...

 

[tagedieb]

Ohne dies jetzt gross getestet zu haben denke ich das der Konstruktor falsch ist.
In der letzten Zeite muss

this.z

verwendet werden. Sonst wird der Wert der lokalen und nicht der Instanzvariable zugewiesen.

 int x, y, z;
 Tester(int a, int z) {
      x = a;
      y = z;
      this.z = x + y;
 }

 

[tagedieb]

Hab mir die Aufgabe nochmal genauers angeschaut. Wo hast du den diese Aufgabe gefunden und in welchem Kontext?

Mir scheint die Aufgabe eignet sich schlecht als Beispiel und gehoert eher in die Kategorie finde die 10 Fehler!!

Instanzvariablen werden durch lokale Variablen ueberschrieben.
- z wird gar nie initialsiert und bleibt 0
- in der Methode m() wird die Instanzvariable x durch einen Lokalvariable ueberschrieben (x = 19)
- Der einzige Wert von Belang im Konstruktor ist y.
- Methode f(): da z = 0 ist ergibt auch das Ergebnis der Division 0. Somit wird immer der Wert der lokalen Variable x zurueckgeliefert. Die f() Methode kann also ignoriert werden weil f(x) = x

    int x = 42; // wird in Methode m() nicht verwendet, da sie ueberschrieben wird
    int y = 23;
    int z = 0;
	void m() {
		int v = 19;
		int w = 19;
		int x = 19;
		v = f(3) * z; // 3 * 0 = 0
		w = y / x - f(f(z + x)); //  23 / 19 - (0 + 19) = 1 - 19 = -18
		x = x + f(y); // 19 + 23 = 42
		y = x - v; // 42 - 0 = 42
		z = f(v) - f(w) + f(z); // 0 - -18 + 0 = 18
	}

 

[Hunter12]

Hallo, erstmal danke für die Antworten. DIe Aufgabe habe ich von hier:

Übungen - AI1-11 - TWiki

Uebung 12 Aufgabe 4 (Scope von Variablen).
Ich habe leider noch nicht ganz verstanden warum z = 0 ist, da doch z als eine int Objektvariable ganz oben deklariert wurde und im Konstruktor wird Die Summe aus x und y doch in dieser Variablen z gespeichert. Wenn man jetzt ein Objekt durch diesen Konstruktor aufruft ist dann nicht z = 42 +23?
Warum kann die Methode m() dieses z nicht verwenden?

 

[DanZ]

Guck mal in der Parameterliste vom Konstruktor und denk über entsprechende Namenskonflikte nach

 

[HimBromBeere]

[JAVA=3]Tester(int a, int z) {
x = a;
y = z;
z = x + y;
}[/code]

Hier steckt das Problem. Du weist in der letzten Zeile deines Konstruktors nicht der Instanzvariablen

z

einen Wert zu, sondern der Parametervariablen

z

. Da beide den selben Namen haben, nimmt der Compiler immer die Referenz mit dem kleinst möglichen Geltungsbereich (hier also die Parametervariable

z

). Um diesen Konflikt zu lösen, musst du vor

z =

ein

this.

schreiben, um damit auszudrücken, du möchtest

z

des Objektes und nicht der Methode verwenden (

this

ist eine Referenz auf das Objekt, in welchem du dich gerade befindest).
Also muss die letzte Zeile lauten: [JAVA=6]this.z = x + y;[/code]

 

[Hunter12]

Achso, danke, jetzt hab ichs verstanden
@ HimBromBeere danke hast du echt super erklärt