a += a++ * a++ * a++ in Java. How does it get evaluated?

Question

I came across this problem in this website, and tried it in Eclipse but couldn\'t understand how exactly they are evaluated.

    int x = 3, y = 7, z = 4;

          


        

Answer 1

Because the increment Operation ++ is added after the variable x. That's a post increment operation. That means, x is incremented after the operation is handled.

In your example the expression would be: 
x += 3 * 4 * 5
First the expression is added by 3 (x+=....)
then the first x++ results in 3
the second x++ results in 4 (because it was incremented before)
and the third x++ results in 5.

If you want your variable incremented before the operation is executed, you have to write ++x (pre increment operation)

Answer 2

unary operators evaluated left to right, so the first x++ gets the value x, the second is (x+1), etc. And the += evaluates according to the value of x at the start, hence the addition of x

Answer 3

Nothing to do with operator precedence per se, just the order of evaluation. Two things to know here:

1. x++ is the postfix increment, so the value of x is incremented after it is evaluated
2. * evaluates the right side then the left side.

Considering point 2, the expression x++ * x++ * x++ can be rewritten more specifically as x++ * (x++ * (x++)).

The whole expression can be written as the procedures:

a = x
x += 1
b = x
x += 1
c = a*b
d = x
x += 1
return c*d

Answer 4

Java evaluates expressions left to right & according to their precedence.

int x = 3, y = 7, z = 4;

x (3) += x++ (3) * x++ (4) * x++ (5);  // gives x = 63
System.out.println(x);

y = y (7) * y++ (7);
System.out.println(y); // gives y = 49

z = z++ (4) + z (5);
System.out.println(z);  // gives z = 9

Postfix increment operator only increments the variable after the variable is used/returned. All seems correct.

This is pseudocode for the postfix increment operator:

int x = 5;
int temp = x;
x += 1;
return temp;

From JLS 15.14.2 (reference):

The value of the postfix increment expression is the value of the variable before the new value is stored.

Answer 5

Because a postincrement modifies the variable after the value is taken and += evaluates its left hand side before evaluating its right hand side,

x += x++ * x++ * x++; 

becomes

tmp0 = x

tmp1 = x
++x
tmp2 = tmp1 * x
++x
tmp3 = tmp2 * x
++x

x = tmp0 + x

Answer 6

The postfix operator x++ means something like "give me the value of x now, but increment it for future references"

So, by the order of operations and evaluation,

x++ * x++ * x++

is interpreted first as

3 * 4 * 5 (=60)

Which is then added to the original 3, yielding 63.

The original value is used because it's on the same line, had you written something like:

int x = 3;

int y += x++ * x++ * x++; 
x += y;

x would now be 66, instead of 63 because the x in the second line is now 6, rather than its original 3.