Compound Assignment Operators

Each compound assignment uses the current value of x. Adding 3 raises the starting value, multiplying by 2 doubles that result, and x-- decreases the variable by 1. Tracing in order keeps an old value out of a later step.

• A is not correct: this applies the decrement to 7 but skips the multiplication, and x *= 2 runs first and doubles the stored value.
• B is not correct: this is the value of x after only the first update, so the trace stops before x *= 2 and x-- have run.
• D is not correct: this is the value reached after the multiplication, but x-- still runs and decreases the variable by 1 before the value is printed.

A compound assignment operator does not change the normal rules of Java arithmetic. Since n is an int and 3 is an int, 8 / 3 uses integer division and discards the fractional part, giving 2 before n++ runs.

• A is not correct: this is the value stored by n /= 3, but n++ then increases n by 1 before the value is printed.
• B is not correct: this would follow from rounding 8 / 3 upward instead of discarding the fractional part, which is not what integer division does.
• C is not correct: a decimal result is never stored, because n is an int and the fractional part is discarded before the updated value is stored.

Java evaluates the entire right-hand expression before combining its result with the variable, so trace x op= expression as x = x op (expression). The second update then works from the current value of a rather than from its starting value.

• A is not correct: the first value is right, but b does not keep its starting value, because b += a % 4 adds the remainder to it.
• B is not correct: reaching 15 for a would require multiplying the current value of a rather than adding the value of b * 3 to it.
• C is not correct: reaching 6 for b would require adding 4 itself instead of the remainder produced by a % 4, and the first value is wrong as well.

When a compound assignment statement is expanded by hand, parentheses belong around the entire right-hand side: x *= a + b becomes x = x * (a + b). The same rule applies here, so the sum is formed before the multiplication takes place.

• A is not correct: this adds the right-hand result to 6 instead of multiplying by it, but the operator in the statement is *=.
• B is not correct: reading the statement as value = value * 2 + 3 would give 15, which is the wrong answer because the entire right-hand expression is evaluated first.
• D is not correct: the statement is valid Java, because the right-hand side of a compound assignment does not have to be a single value; it may be a whole expression.

When several variables change, each later statement uses their current values. A tracing table records those changes in order and prevents an old value from being carried into the next calculation. Here the increment runs before the multiplication, so the multiplication uses the updated value.

• A is not correct: this multiplies y by the starting value of x rather than by its current value, and the final subtraction is then applied to that same stale value.
• C is not correct: the second value is right, but x -= 2 still runs and lowers x from 4 before the printing statement.
• D is not correct: reaching these values would require x to hold 5 when the multiplication runs, but x++ increases x by 1 only.

The %= operator follows the usual remainder rules for its operand types, so it stores the remainder rather than the result of the division. Each later statement then uses the current value, which is why the trace has to be taken one statement at a time.

• B is not correct: this is the value stored by the remainder step alone, but two more statements run and change value before it is printed.
• C is not correct: this is the value after the multiplication, but value-- then decreases the variable by 1 before the printing statement.
• D is not correct: reaching 11 would require the remainder step to leave a larger value, but value %= 6 stores the remainder of the division and nothing else.

Trace x op= expression as x = x op (expression). Java reads the current value of the variable, combines it with the right-hand value using the matching arithmetic operator, and stores the result back into that same variable.

• B is not correct: this reverses the operands. Subtraction is not symmetric, so subtracting the variable from 6 is a different calculation from the one the operator performs.
• C is not correct: this adds instead of subtracting, which is what += does, while -= combines the variable with the right-hand value by subtraction.
• D is not correct: this multiplies the current value, which is how *= is expanded, but the operator written in the statement is -=.

Forgetting those parentheses is one of the most common tracing errors on this topic. Java evaluates a + b and only then combines the result with x, which is why x = x * (a + b) is the correct expansion.

• A is not correct: this multiplies x by a and then adds b, so the variable is combined with only part of the right-hand expression.
• B is not correct: the added parentheses group x * a, which changes nothing about the order of evaluation, so this carries the same meaning as the previous expansion.
• C is not correct: this drops the current value of x from the right-hand side, but a compound assignment operator updates a variable using its current value.

Written by itself as count + 1, the line is not a valid Java statement, so the code does not compile. To update the variable, use count = count + 1, count += 1, or count++.

• A is not correct: an integer literal is not the problem, since count += 1 uses a literal as well and does update the variable.
• C is not correct: addition can update an int once the result is stored, as in count = count + 1, so the operation itself is not what fails here.
• D is not correct: the variable does not have to appear twice on the right, since count += 1 and count++ both update the variable without repeating it.

Java provides a compound assignment operator for each arithmetic operator, and each one keeps the meaning of that operator. The remainder operator produces what a division leaves over, so %= stores that leftover amount back into the variable.

• A is not correct: this stores the result of the division rather than the remainder, and for an int the fractional part is discarded instead of being kept.
• B is not correct: this multiplies the current value by 5, which makes the variable larger rather than reducing it to what a division leaves over.
• D is not correct: this subtracts 5 once from the current value, which is a single subtraction rather than the remainder left after dividing.

The increment operator ++ increases a variable by 1, and the decrement operator -- decreases a variable by 1. Used as a standalone statement, count-- is traced as count = count - 1.

• A is not correct: this increases the variable, which is the trace of ++, while -- moves the stored value in the opposite direction.
• C is not correct: this decreases the variable by 2 rather than by 1, and the decrement operator changes a variable by 1.
• D is not correct: this replaces the current value with 1 instead of decreasing it, and a compound update keeps the variable's current value in the calculation.