الإسناد والإسناد المركّب

Written Explanation

= is an action, not an equation

In algebra, x = x + 1 is nonsense. In Java it is an instruction with a clear order:

1. Calculate the right side using the current values.
2. Store the result in the variable on the left.

So with int x = 4;, the statement x = x * x + 1; computes 4 * 4 + 1, which is 17, and only then replaces the old 4 with 17. The old value is used up before the new one is stored. That is why you can safely use a variable on both sides.

The left side must be a variable (a box). 5 = x is an error, because 5 is a value, not a place to store something.

Assignment is also an expression: x = 7 has a value (the value stored), which is what makes chaining possible.

Chained assignment

a = b = c = 7; stores 7 in all three variables. The Java Tutorials state that assignment operators are evaluated from right to left, so this is read as a = (b = (c = 7)): first c gets 7, that value goes to b, then to a. Every variable must already be declared (int a, b, c;). Use it sparingly; one assignment per line is easier to read.

Compound assignment

Updating a variable from its own value is so common that Java has shortcuts:

All the rules from Lesson 1 still apply: with int x, the shortcut x /= 2 does integer division.

The right side is calculated completely first

With a compound operator, the whole right side is evaluated before it is combined with the variable. That is the same as putting parentheses around it:

int x = 5;
x *= 2 + 1;   // x = x * (2 + 1), so x is 15, not 11

The Java Language Specification defines E1 op= E2 as E1 = (T)((E1) op (E2)), where T is the type of E1, apart from the detail that E1 is evaluated only once. Notice the parentheses around E2. They are the reason x *= 2 + 1 multiplies by 3.

The hidden cast

The (T) in that definition is a cast back to the type of the variable, written for you. It matters when the right side has a wider type than the variable:

int n = 10;
n += 2.7;        // compiles: n = (int) (n + 2.7), so n is 12
n = n + 2.7;     // does NOT compile: possible lossy conversion from double to int

The long form is refused by the compiler, as you learned in BEG-009, because it would silently lose the .7. The short form quietly casts and loses it anyway. Neither the cast nor the data loss is shown anywhere in your code. The same hidden cast can hide overflow:

byte small = 100;
small += 100;    // compiles; the true result 200 wraps to -56

So += is convenient, and it also turns off a safety check. Use it freely with matching types, and think twice when the right side is a different type.

+= on text

A String accepts += too, and it means "append". It builds a new string and assigns it (BEG-009 showed that strings never change in place):

String s = "Hi";
s += " there";   // "Hi there"
s += 1 + 2;      // 1 + 2 is calculated first (3), so "Hi there3"

Only += works on a String. -= or *= do not.

Swapping two values

Because the right side is calculated before storing, a swap needs a helper box:

int temp = a;
a = b;
b = temp;

Writing a = b; b = a; fails because the first line overwrites a before it has been saved.