Java Assignment Operators

Table of Contents +

In the last lesson you learned about Java arithmetic operators. Updating a variable using its own value, like score = score + 10, is so common that Java gives you shorter ways to write it. These are the assignment operators.

🟰 The basic assignment

The = sign is the basic assignment operator.

It puts the value on the right into the variable on the left.
It does not mean “is equal to” like in math; it means “put this value into this name”.
Java works out the whole right side first, then stores that single result on the left.

int score = 10;
System.out.println(score);

That two-step order matters when the variable is on both sides:

In score = score + 10, Java reads the old score first, adds 10, then writes the result back.
Reading happens before writing, so the two sides never fight each other.
Every other assignment operator is just a shorter way to write this same idea.

int score = 10;
score = score + 10;   // right side first: 10 + 10 = 20, then store 20
System.out.println(score);

Output

➕ Compound assignment operators

One pattern repeats everywhere: take a variable, do math on it, store the result back. A compound assignment operator shortens this by gluing the math operator onto the =.

score = score + 10 becomes score += 10, doing exactly the same thing.
The rule: x OP= value always means x = x OP value.
This saves typing the variable name twice.

Here are all five:

Operator	Short form	Same as
+=	x += 5	x = x + 5
-=	x -= 5	x = x - 5
*=	x *= 5	x = x * 5
/=	x /= 5	x = x / 5
%=	x %= 5	x = x % 5

Think of it like a bank balance you keep adjusting. You say “add 50”, “take away 30” instead of rewriting the whole balance. Watch the same total update step by step:

int total = 100;
total += 50;   // total = total + 50 -> now 150
total -= 30;   // total = total - 30 -> now 120
total *= 2;    // total = total * 2  -> now 240
total /= 4;    // total = total / 4  -> now 60
System.out.println(total);

Each line changes total using its own current value, so it walks 100 to 150 to 120 to 240 to 60.

Output

The %= one surprises people. The % operator gives the remainder after division, so %= stores that remainder back:

int items = 17;
items %= 5;   // remainder of 17 / 5 is 2, so items becomes 2
System.out.println(items);

17 divided by 5 is 3 with 2 left over, so items becomes 2. Handy for wrapping a big count into a position from 0 to 4.

Output

🔤 Using += to join text

The + operator does two jobs in Java:

With numbers it adds.
With text it joins, which is called concatenation.
So += on a String adds more text onto the end.

String name = "Al";
name += "ex";     // name = name + "ex" -> "Alex"
name += " Smith"; // now "Alex Smith"
System.out.println(name);

So name grows from "Al" to "Alex" to "Alex Smith". The space inside " Smith" is on purpose so the words don’t run together.

Output

Alex Smith

You can even join a number onto text with +=; Java turns the number into text first:

String label = "Score: ";
int points = 90;
label += points;   // number 90 becomes the text "90"
System.out.println(label);

So label ends up as "Score: 90". The number 90 became the characters 9 and 0 and got glued on.

Output

Score: 90

🔁 Chained assignment

You can set several variables to the same value in one line, called chained assignment:

It works because = hands back the value it just stored.
The next = to its left can reuse that returned value.

int a, b, c;
a = b = c = 0;   // c gets 0, then b gets 0, then a gets 0
System.out.println(a + " " + b + " " + c);

Read it right to left: c = 0 runs and gives back 0, then b takes it, then a takes it too. A neat way to reset a few counters at once.

Output

0 0 0

Use chaining sparingly

Chained assignment is handy for setting a few variables to the same starting value. But long chains get hard to read, and they only work when every variable is the right type. So keep chains short and obvious.

🎭 The hidden cast inside compound assignment

This trick is rarely taught and causes real confusion, so go slow:

A byte only holds small whole numbers, from -128 to 127.
Java does the math as int (a bigger type), so b + 5 produces an int, not a byte.
You can’t drop an int back into a byte without saying you mean it; that step is a cast, written (byte).

So the plain version needs a cast:

byte b = 10;
// b = b + 5;          // ❌ error: b + 5 is an int, won't fit in a byte by itself
b = (byte) (b + 5);    // ✅ the (byte) cast says "yes, store it as a byte"
System.out.println(b);

But the compound version works with no cast at all:

byte b = 10;
b += 5;   // ✅ works fine, no cast needed
System.out.println(b);

Both print 15. The reason b += 5 works but b = b + 5 does not:

Java quietly adds the cast inside every compound operator, so b += 5 really means b = (byte)(b + 5).
b = b + 5 is plain assignment, so you must add the cast.
b += 5 is compound, so Java adds it for you.

Output

The hidden cast has a sharp edge: because it is silent, a compound operator can throw away part of a number without warning:

byte b = 100;
b += 50;   // 100 + 50 = 150, but a byte maxes out at 127
System.out.println(b);

150 is too big for a byte, so the hidden cast chops it down and you get -106. The compiler stays quiet because you used +=, so the convenience can hide a real bug.

Output

-106

The takeaway

+= and friends always cast the result back to the variable’s own type. That saves you typing on small types. But it can also silently shrink a value that grew too big. So with byte and short, keep an eye on whether your numbers can overflow.

➕➕ Increment and decrement

Adding or subtracting exactly 1 is so common (especially in loops) that Java has dedicated operators:

Increment ++ adds 1.
Decrement -- subtracts 1.

int count = 5;
count++;   // same as count = count + 1, now 6
count++;   // now 7
count--;   // now 6
System.out.println(count);

So count++ is the shortest way to write count = count + 1. You’ll see ++ constantly in loops, stepping a counter up one at a time.

Output

🔀 Pre vs post: a subtle point

You can write ++ before the variable (++count) or after it (count++):

On its own line, both add 1 and behave the same.
The difference only shows when you use the value in the same statement.
Post count++ uses the current value first, then adds 1.
Pre ++count adds 1 first, then uses the new value.

This example prints the difference clearly:

int a = 5;
System.out.println(a++);   // prints 5, then a becomes 6
System.out.println(a);     // prints 6

int b = 5;
System.out.println(++b);   // b becomes 6 first, then prints 6

With a++, Java prints the old value 5 then bumps a to 6. With ++b, Java bumps b to 6 first then prints 6. The position of the ++ decides when the add happens.

Output

5
6
6

Keep it simple at first

When ++ sits alone on its own line, pre and post do the same thing, so you do not need to worry about the difference. The distinction only matters when you read the value in the same line. When in doubt, put ++ on its own line.

⚠️ Common Mistakes

A few assignment slip-ups to avoid:

Confusing = with ==. A single = assigns; a double == checks if two things are equal. Mixing them up is a classic bug.

// ❌ Avoid: using = where you meant to compare
// if (score = 10) ...   // assigns 10, does not compare

// ✅ Good: == compares
if (score == 10) {
    System.out.println("Exactly ten");
}

Assuming += needs a cast like = does. It doesn’t; += already casts for you.

byte b = 10;
// b += (byte) 5;   // ❌ extra cast, not needed
b += 5;             // ✅ compound assignment casts for you

Writing the operator backwards. It is +=, not =+. x =+ 5 is read as x = (+5), which just sets x to 5 and ignores its old value.
Forgetting that small types can overflow. Because += hides the cast, a byte or short can wrap past its limit with no warning.
Cramming ++ into a bigger expression. Mixing a++ into a larger line makes code hard to follow; keep ++ on its own line.

✅ Best Practices

Habits for clean assignment:

Use compound operators. total += 50 is shorter and clearer than total = total + 50.
Trust the built-in cast on small types, but watch the range. b += 5 casts for you; just make sure the result still fits in a byte or short.
Use ++ and -- for stepping by one. They make loop counters clean and obvious.
Keep increment simple. Put ++ or -- on its own line unless you have a clear reason not to.
Keep chains short. a = b = c = 0 is fine for resetting a few values, but don’t stretch it out.

🧩 What You’ve Learned

Nicely done. Let’s recap.

✅ The basic = works out the right side first, then stores that result on the left.
✅ Compound operators (+=, -=, *=, /=, %=) shorten “update a variable with its own value”; x OP= v means x = x OP v.
✅ += also joins text onto a String, and can stick a number onto text.
✅ Chained assignment like a = b = c = 0 sets several variables in one line, right to left.
✅ Compound operators cast the result back for you, so b += 5 works where b = b + 5 needs a cast. But that hidden cast can silently overflow small types.
✅ ++ adds 1 and -- subtracts 1; post (a++) uses then adds, pre (++a) adds then uses.
✅ Do not confuse = (assign) with == (compare).

Check Your Knowledge

Test what you learned. Pick an answer for each question, then click Check.

🚀 What’s Next?

You can store and update values smoothly now. But how does a program make decisions, like checking if a score is high enough? That starts with comparing values. Let’s look at comparison operators next.

Java Relational Operators

Previous Java Arithmetic Operators Next Java Relational Operators

Share & Connect

Share on LinkedIn