Java Inkrement funktioniert nicht

[vram78]

public class test2 {
public static void main(String[] args) {

int a = 3;
int b = 5;
int c = 6;
boolean b_wert;

b_wert = b < c & a++ == 4;

System.out.println(b_wert);

System.out.println(b_wert);



int a1 = 5;
System.out.println(a1++);
System.out.println(a1);


}
}

Beim b_wert erwarte ich beim 1. mal aufrufen des println Befehls false. Beim zweiten println Befehl jedoch true...

Trotzdem wird zweimal false angezeigt. Wieso? Bei der Postfixform der Inkrementierung wird die Variable ja NACH einem Zugriff erhöht. Aber da passiert nichts!

Bei dem anderen Beispiel geht das. wenn ich das erste mal "a1" aufrufe, kommt 5. Beim zweiten mal kommt dann die 6...


Wo ist mein Denkfehler??




MFG

 

[Donnidonis]

Ich denke du willst && nutzen und nicht das einfach &. Das wäre nämlich das AND verknüpfen zweier Zahlen.

 

[vram78]

Kommt trotzdem false raus...

 

[Donnidonis]

Ist ja auch richtig. Der Wert von b_wert ändert sich ja nicht nochmal nachdem ein Print ausgeführt wird. Der Wert von a ändert sich auf 5, mehr nicht.

 

[Raybeez]

In den Zeilen 18+19 funktioniert das was du planst, weil du die Ausgabe mit dem Inkrement verschachtelst.
System.out.println(a1++);
bedeutet "Gib a aus und erhöhe es dann".

Die Ausgabe von b_wert verschachtelst du aber nicht mit der Ausgabe.
post-inkrement heißt nicht, dass mit dem inkrement gewartet wird bis du irgendwann mal darauf zugreifst. In Zeile 9 wird b_wert festgelegt. Danach wird daran nichts mehr geändert. Grob gesagt bezieht sich post- und prä-inkrement nur auf die Dinge, die du in der gleichen Zeile im Quellcode machst.

 

[vram78]

Also wo ich b_wert festgelegt habe: a++ ist doch dann unnötig oder?

 

[KRON05]

Ich denke du willst && nutzen und nicht das einfach &. Das wäre nämlich das AND verknüpfen zweier Zahlen.

Bei & wird die Auswertung für den ganzen Ausdruck durchgeführt auch wenn das Ergebnis bereits feststeht.
Bei && aber nicht, Bsp.: "1 > 2 && a++ == 3": Weil "1 > 2" false ist wird durch die AND-Verknüpfung das Gesamtergebnis ebenfalls false. a++ == 3 wird dann nicht mehr ausgewertet(und auch nicht inkrementiert).

Ergänzung (22. Oktober 2017)

Also wo ich b_wert festgelegt habe: a++ ist doch dann unnötig oder?

Ja, b_wert wird nach Zeile 9 direkt false zugewiesen. a++ ist unnötig.

So würde es das Ergebnis ändern:
b_wert = b < c & a++ == 4;
System.out.println(b_wert);
b_wert = b < c & a++ == 4;
System.out.println(b_wert);

 

[Burfi]

@vram78:
Mein Vorschlag wäre, dass du dich an die Java Coding Guidelines hälst. Dann würden solche Probleme nämlich nicht auftreten.
Sprich in diesem Fall gilt "Eine Anweisung pro Zeile". a++ gehört also in eine eigene Zeile.

 

[vram78]

Naja, dass war eine Aufgabe in einem Java-Lehrbuch.

Ich sollte ohne den Code in Eclipse einzugeben mir erdenken, welche Ausgabe erfolgt. Als ich auf die Lösung geschaut habe konnte ich es nicht nachvollziehen.



Hier mein Gedankengang:

b ist kleiner als c. Das ist schon mal true. Daraufhin nehme a , erhöhe es auf 4 und vergleiche, ob es gleich 4 ist. Bedeutet, dass b_wert nun true ist.

Beim ersten mal Aufrufen von b_wert ist es noch false, da Postinkrement angewendet wurde. Erst beim 2. mal Aufrufen ist es dann true.

Ergänzung (22. Oktober 2017)

Ich kapier es einfach nicht.

Mein Code:

b_wert = b < c & a++ == 4;

System.out.println(b_wert);

System.out.println(b_wert);


Dein Code:

b_wert = b < c & a++ == 4;
System.out.println(b_wert);
b_wert = b < c & a++ == 4;
System.out.println(b_wert);


Du hast da einfach was dazwischengesetzt und schon funktioniert es. Ich kann es aber irgendwie nicht nachvollziehen, wieso bei deinem Code zuerst false , dann true ausgegeben wird, bei meinem Code aber false und false ausgegeben wird...

Ergänzung (22. Oktober 2017)

Hier in Pseudocode, wie ich es verstehe:

b_wert = b ist kleiner als c (wahr) |||überprüfe, ob anderer Operand wahr ist||| erhöhe a erst dann, wenn println zum 2. mal ausgegeben wird == 4; (noch ist es false)
System.out.println(b_wert); (false, weil a immer noch 3 ist)
System.out.println(b_wert); (true, weil beim 2. mal der Wert von a in 4 geändert wird.)

 

[marcOcram]

Beim ersten mal Aufrufen von b_wert ist es noch false, da Postinkrement angewendet wurde. Erst beim 2. mal Aufrufen ist es dann true.

b_wert ändert sich nicht, wenn du die Variable irgendwo ausgibst. Du weist der Variable einmal den Wert zu, den du in deiner Anweisung (b < c & a++ == 4) berechnest. Danach hat b_wert diesen Wert und ändert sich nicht mehr ohne eine weitere Zuweisung.

Einfacheres Beispiel:

int a = 0;
boolean b_wert = (a++ == 1); // b_wert = false, da dass Post-Inkrement erst nach der Zuweisung ausgeführt wird und somit a noch 0 ist.

System.out.println(b_wert); // false
System.out.println(b_wert); // false
[...]
System.out.println(b_wert); // false

EDIT:

Ich habe deinen Code mal anders geschrieben:

public class test2 {
  public static void main(String[] args) {
    int a = 3;
    int b = 5;
    int c = 6;
    boolean b_wert;

    // deinen Ausdruck habe ich in mehrere Variablen (temp1 und temp2) unterteilt

    boolean temp1 = b < c; //  => true
    boolean temp2 = a++ == 4; // false, da erst a gelesen wird, dann erhöht wird und dort somit 3 == 4 steht.
    // a hat jetzt den Wert 4;

    b_wert = temp1 & temp2 // b_wert kriegt das Ergebnis von (temp1 & temp2) zugewiesen => false (Achtung: binärer UND-Operator!)
 
    System.out.println(b_wert); // lese den Wert von b_wert aus und schreibe es in die Ausgabe => false
    System.out.println(b_wert); // lese den Wert von b_wert aus und schreibe es in die Ausgabe => false
 
    int a1 = 5;
    System.out.println(a1++); // lese den Wert von a1 aus, erhöhe diesen um 1 und schreibe es in die Ausgabe => 5
    System.out.println(a1); // lese den Wert von a1 aus und schreibe es in die Ausgabe => 6
  }
}

 

[vram78]

Achso. Und wenn ich b_wert = b < c & a++ == 4


zwischen einem Println-Befehl setze?

 

[marcOcram]

Dann wird die Zuweisung erneut ausgeführt.

b_wert = b < c & a++ == 4  // false, a wurde danach von 3 auf 4 erhöht.
System.out.println(b_wert); // lese b_wert aus und schreibe es in die Ausgabe => false
b_wert = b < c & a++ == 4  // true, weil a auf 4 erhöht wurde. a hat danach den Wert 5.
System.out.println(b_wert); // lese b_wert aus und schreibe es in die Ausgabe => true

 

[vram78]

jetzt hab ich es kapiert erst nach einem weiteren ZUGRIFF auf die Variable funktioniert die Post-Inkrementierung.

danke

 

[marcOcram]

Irgendwie bezweifel ich, dass du es komplett richtig verstanden hast. Bei einem weiteren Zugriff hast du einfach den aktuellen Wert deiner Variable.

Bei der Post-Inkrementierung wird erst der Wert gelesen und danach erhöht.
Bei der Pre-Inkrementierung wird erst der Wert erhöht und dann gelesen.

Beispiele:

int a = 0;

System.out.println(a); // 0 => lese a aus und schreibe es in die Ausgabe
System.out.println(a++); // 0 => lese a aus, erhöhe a um 1 und schreibe den gelesenen Wert in die Ausgabe
System.out.println(a); // 1 => lese a aus und schreibe es in die Ausgabe

int a = 0;

System.out.println(a); // 0 => lese a aus und schreibe es in die Ausgabe
System.out.println(++a); // 1 => erhöhe a um 1, lese a aus und schreibe den gelesenen Wert in die Ausgabe
System.out.println(a); // 1 => lese a aus und schreibe es in die Ausgabe

 

[vram78]

Na so meine ich es doch:

System.out.println(a++); // gibt immer noch 0 aus
System.out.println(a) //jetzt gibt es 1 aus

System.out.println(++a); // Gibt 1 aus
System.out.println(a) //Gibt wieder aus



Denke ich hab's verstanden danke