Verständnisproblem Nr 2

[Angelika_25]

Ich habe diesen Code:

public class Laufzeit 2 {
   public static int next (int v) {
     return v++ % 4;
   }
   public static void main (String[] args) {
     int[]z={'a', 'b', 'c','d'};
     int i=1;
     while (true) {
       System.out.println(i+ " "+z[i]);
       z[i]=z[i-1]/z[i];
       i=next(i);
     }
   }
}

Bei diesem Code weiß ich auch, dass er kompilierbar ist, aber ein fehlerhaftes Laufzeitverhalten hat.
Meine erste Frage zu der while Schleife:
Ist am Programmstart immer alles zuerst true?

Dann eine Frage zu der Methode next:
Ich übergebe ja i, also steht in der formalen Variable der Wert 1.
Was gebe ich als return Wert zurück? Wenn da nur v stehen würde und nicht v++, dann 1, aber so?
Ich gebe doch trotzdem den Wert 1 zurück, weil ja erst später erhöht wird, aber wann wird denn erhöht? Wann muss für i=2 stehen??

Sorry für die vielen blöden Fragen .

Liebe Grüße

 

[hdi]

Ist am Programmstart immer alles zuerst true?

Was meinst du mit "alles"? Dort steht ein true, und ja, das ist true

Dann eine Frage zu der Methode next:
Ich übergebe ja i, also steht in der formalen Variable der Wert 1.

du meinst lokale Variable, "formale" Variable hab ich noch nie gehört.

Was gebe ich als return Wert zurück? Wenn da nur v stehen würde und nicht v++, dann 1, aber so?

Du gibst in der Methode immer v%4 zurück.
edit: sorry mein Fehler, das ist natürlich 1, richtig.

aber wann wird denn erhöht?

Sobald das return fertig ist. Also nach der Rückgabe.

Wann muss für i=2 stehen??

Wat?

 

[Angelika_25]

Sorry für die vielleicht unglückliche Formulierung. Am Anfang des Codes steht ja "while (true)", was bedeutet das? Solange es true ist? Aber was denn eigentlich?
Jetzt zu der Methode:
Es wird als aller erstes eine 1 zurück gegeben. Wenn ich dann

i=next(i);

sehe, dann bekommt i den Wert 1. Aber erhöht ist es ja dann noch nicht, wann wird erhöht?
Ist i dann beim zweiten Schleifendurchlauf 2?

 

[hdi]

Zu den Bedingungen:

Normalerweise hast du einen Ausdruck, der als boolean ausgewertet werden kann:

while(x < 10) zB.

x<10 ergibt entweder true oder false, beim Auswerten dieses Ausdrucks gibt Java
diesen Wert zurück, also quasi wie bei einem return von ner Methode.

Im Endeffekt steht dann also drin, sagen wir wenn x = 14 ist:

while(false)

D.h. am Ende ist es eh nur ein boolean, du kannst den also direkt reinschreiben.
Da "ist" nix true, das bezieht sich auf nix. Das ist einfach true. Steht für jeden beliebigen
Ausdruck, der true sein könnte.

Also... du könntest auch schreiben

while(true == true)

wenn du das dann besser verstehst. Es ist einfach true.

Aber erhöht ist es ja dann noch nicht, wann wird erhöht?
Ist i dann beim zweiten Schleifendurchlauf 2?

Wie gesagt: v wird nach dem returnen immer um eins erhöht.

Das

return v++%4

ist eigentlich das hier:

return v%4;
v = v+1; // sozusagen, normalerweise kann nach einem return nix stehen

So, aber v ist wieder nur eine lokale Variable, es ist wieder nur eine Kopie von i.
Was mich grad irgendwie schockt, ich dachte bei Primitiven ist es Call-By-Value?
Naja zumindest passiert nix: i wird reingegeben in die next-Methode, und kommt
genauso wieder raus. D.h. i verändert sich nicht und bleibt die ganze Zeit bei seinem
Anfangswert = 1

 

[Mostly_Harmless]

Sorry für die vielleicht unglückliche Formulierung. Am Anfang des Codes steht ja "while (true)", was bedeutet das? Solange es true ist? Aber was denn eigentlich?

[HIGHLIGHT="Java"]
while ( BEDINGUNG ) {
// doSomething
}
[/HIGHLIGHT]

In dem runden Klammerpaar hinter while steht die Bedingung, die erfüllt sein muss, damit die Schleife erneut ausgeführt wird. Die Bedingung ist eine Anweisung/Reihe von Anweisungen, die ausgewertet immer true oder false ergeben muss/müssen.
Da in deinem Programm nun true als Bedingung dort steht, wird die Schleife immer wieder ausgeführt, es handelt sich also um eine Endlosschleife.

Jetzt zu der Methode:
Es wird als aller erstes eine 1 zurück gegeben. Wenn ich dann

i=next(i);

sehe, dann bekommt i den Wert 1. Aber erhöht ist es ja dann noch nicht, wann wird erhöht?
Ist i dann beim zweiten Schleifendurchlauf 2?

Nein, dein i wird niemals erhöht, da der return Wert ja immer 1 ist.

 

[hdi]

So okay, sorry dafür dass ich jetzt vorhin dich vllt verwirrt hab.
Hatte grad n Knoten im Hirn:

Also, bei Primitiven Datentypen (du weisst ja jetz was das is, siehe Frage1),
arbeitet Java mit "Call-By-Value".

D.h. das v hat nur den Wert von i in der next()-Methode, aber es hat mit der
Variablen i NIX zu tun.

Du erhöhst also v nach dem returnen, und sobald die next-Methode() am Ende ist,
ist v aber zerstört, das gibt's nicht mehr.

Deswegen: Was du in next() reinsteckst, kommt genauso zurück.

Das ist so wie vorhin mit deinem f-array, es war auch nur eine Kopie. Da war's aber
eine Kopie der Referenz, es war ein nicht-primitiver Datentyp, dort ist es
"Call-By-Reference" (Achtung: Dieses Stichwort führt hier oft zu Schlägereien,
es ist nicht wirklich Call-By-Reference, aber lassen wir das mal).

Was ich sagen will:

Bei Primitiven ist das übergebene innerhalb der Methode echt was GANZ anderes.
Bei nicht-Primitiven ist es nen Zeiger auf das, was du reingesteckt hast, du kannst
also wirklich das Objekt verändern.

Ausnahme: Die Referenz auf's Objekt kannste nicht ändern, also du kannst
nicht sagen:

x = y

Hoffe, ich hab dich jetz nich zu sehr verwirrt. Ist klar, was ich meine?

 

[Angelika_25]

Langsam verstehe ich alles immer besser. Was ist, wenn dort stehen würde:

while (false);

Dann würde ich auch in die Schleife gehen?

In meiner Lösung steht, dass dieses Programm ein Laufzeit-Fehler ergibt, da im 2. Durchlauf eine Divison durch 0 stattfinden würde. Das verstehe ich aber dann nicht, wenn sich doch i nicht verändert.....

 

[hdi]

nein dann würde er natürlich nicht in die Schleife gehen.
false ist false. true ist true. "Echte" Ausdrücke, die man normalerweise da reinschreibt,
wie eben zB x == 5 oder sonstwas, werden ja auch nur ausgewertet und sind am Ende
dann halt true oder false.

 

[hdi]

Die Lösung hat auch recht. Aber es ist nicht i, dass sich verändert.
(Siehst du ja auch in der Ausgabe: Es ist in beiden Durchläufen 1).

Aber du änderst ja den Inhalt von dem Array, und mein Gott, beim zweiten
Durchlauf ist z[1] halt nicht mehr das, was es beim ersten Durchlauf war,
und irgendwo teilst du dann durch 0.

 

[Mostly_Harmless]

In meiner Lösung steht, dass dieses Programm ein Laufzeit-Fehler ergibt, da im 2. Durchlauf eine Divison durch 0 stattfinden würde. Das verstehe ich aber dann nicht, wenn sich doch i nicht verändert.....

Also, da i immer 1 ist, kannst du für folgende Zeile
[HIGHLIGHT="Java"]z=z[i-1]/z;[/HIGHLIGHT]
auch einfach diese schreiben:
[HIGHLIGHT="Java"]z[1]=z[0]/z[1];[/HIGHLIGHT]

D. h. im ersten Durchlauf setzt du in den 2. Slot deines Arrays (welcher den Index 1 hat) das Ergebnis von 'a' / 'b'. Mit chars kannst du wie mit int-Werten rechnen.
Da du hier mit ganzzahligen Werten rechnest, ist das Ergebnis 0.
Also passiert im 1. Durchlauf der Schleife folgendes:
[HIGHLIGHT="Java"]z[1]=0;[/HIGHLIGHT]

Daher versuchst du im 2. Durchlauf durch 0 zu teilen, weshalb es zur Exception kommt.

 

[Angelika_25]

Ja du sagst irgend wann? Aber woher weiß ich, dass es genau der 2. Durchlauf ist, bei dem ich durch 0 teile?

 

[hdi]

Zugegeben dass muss man erstmal wissen:
Wenn du chars als int-Werte behandelst, was du tust sobald du das Geteilt-Zeichen
anwendest, wandelt er den char-Wert in einen int Wert um.
(du kannst ja nicht zwei Buchstaben durcheinander teilen, das hätte dir also schon
komisch vorkommen müssen)

Bei dieser Umwandlung gilt:

a = 97
b = 98
c = 99
usw.

Das steht in dieser Tabelle:

Ascii Table - ASCII character codes and html, octal, hex and decimal chart conversion

 

[Civilazi]

Irgendwann steht doch da nirgends?...

Na ja, mal ein paar Anregungen:
Die int-Werte sind: 'a' = 97 , 'b' = 98, ... , 'd' = 100.
Nimm dir doch einfach einen Stift und mach mal das, was in der Schleife auch passiert --> teile 97 / 98 (ganzzahlige Division!) etc...

Und mal nebenbei: Dass i immer 1 ist liegt nicht an primitiven Typen oder sonstwas, sondern daran, dass

[HIGHLIGHT="Java"]int v = 1;
v = v++ % 4; //v == 1

// aber:
int d = 1;
d = ++d % 4; //d == 2[/HIGHLIGHT]

EDIT: Zu spät... wobei die "Umwandlung" nicht erst bei der Division passiert, es ist ja ein int - Array.

 

[hdi]

Dass i immer 1 ist liegt nicht an primitiven Typen oder sonstwas

Es liegt auch an primtiven Typen. Sonst würde ja v++ greifen, wenn auch
erst nach dem return. (bzw. eine analoge Datenstruktur zur Inkrementierung).
Also anders gesagt: Wäre es nicht call-by-value, würde es i verändern,
und zwar sowohl bei ++v als auch bei v++.

wobei die "Umwandlung" nicht erst bei der Division passiert, es ist ja ein int - Array.

Right, hab ich gar nich gesehen.

 

[Civilazi]

Es liegt auch an primtiven Typen. Sonst würde ja v++ greifen, wenn auch
erst nach dem return. (bzw. eine analoge Datenstruktur zur Inkrementierung).
Also anders gesagt: Wäre es nicht call-by-value, würde es i verändern,
und zwar sowohl bei ++v als auch bei v++.

Klingt plausibel Aber wenigstens kann man das ganze so "retten" .