الزيادة والنقصان والأسبقية

Written Explanation

The increment and decrement operators

i++ adds 1 to i, and i-- subtracts 1. They are shorthand for i += 1 and i -= 1. As their own statement, i++; and ++i; do exactly the same thing:

int n = 3;
n++;
++n;
// n is now 5

The operand must be a variable. 5++ is not valid, because there is no box to store the new value in.

Prefix and postfix

Both forms change the variable by one. They differ in the value of the expression itself, which you only see when you use that value:

The Java Language Specification says the same thing for each form: postfix returns the value from before the update, and prefix returns the value after it. One way to remember: the symbol's position tells you when the change happens relative to the use. In i++ the variable is used, then it increments. In ++i it increments, then it is used.

int i = 5;
int a = i++;   // a gets 5, then i becomes 6
int b = ++i;   // i becomes 7, then b gets 7

Why you should limit them

An increment that is used inside a larger expression is allowed, but it is hard to read. Consider:

int k = 1;
int r = k++ * 10 + k;

Java evaluates operands from left to right (JLS section 15.7). First k++ gives 1 and k becomes 2. Then 1 * 10 is 10, and the second k is read as 2, so r is 12. The answer depends on the order of reading, which is exactly what readers misjudge.

A worse trap: m = m++; leaves m unchanged. The right side gives the old value, the increment happens, and then the assignment stores the old value back over it. Good style: use ++ and -- as separate statements, and use the value of the expression only in simple cases such as int id = next++;.

Precedence: which operator goes first

Precedence is the rule for which operator is applied first when an expression has several. It is the same idea as "multiplication before addition". The Java Tutorials list the operators from highest to lowest precedence. Here is the part you need for this module:

Operators on the same row have equal precedence. Operators on a higher row bind more tightly. That is why:

• 2 + 3 * 4 is 14, because * is applied before +.
• 10 - 2 * 3 > 3 + 0 first does the arithmetic (4 > 3), then the comparison, giving true.
• 5 > 3 && 2 + 2 == 4 || false does the arithmetic, then the comparisons, then &&, then ||.
• Assignment is last, so x = 2 + 3 computes the sum before storing.

This table is why Lessons 1 to 3 worked: n % 2 == 0 applies % first, then ==, and cartItems > 0 && !suspended applies the comparison and the ! before the &&.

Equal precedence: left to right

When two operators from the same row appear next to each other, Java groups them from the left (assignment is the exception: it groups from the right, as you saw with a = b = 7).

• 20 - 5 - 3 is (20 - 5) - 3, which is 12. It is not 20 - (5 - 3), which is 18.
• 7 / 2 * 2.0 is (7 / 2) * 2.0. The 7 / 2 is integer division and gives 3, so the result is 6.0. Compare 7 / (2 * 2.0), which is 1.75.
• 2 + 3 * 4 % 5: * and % are on the same row, so 3 * 4 is 12, then 12 % 5 is 2, then 2 + 2 is 4.

The second example is a trap worth remembering: the type of each division is decided by its own two operands, so an early int / int can drop the fraction even if a double appears later in the expression.

Parentheses

Parentheses override precedence. They are evaluated first, innermost first. You do not have to memorize the whole table. A good rule is: know the big ordering (arithmetic, then comparison, then &&, then ||), and add parentheses whenever a reader could hesitate. (a && b) || c has the same meaning as a && b || c, and it is much safer to read.