Unary operators in Java - Step-by-Step Execution

Concept Flow - Unary operators

Start

↓

Apply unary operator

↓

Evaluate expression

↓

Update variable if needed

↓

Use result

↓

End

Unary operators take one value, change or use it, then produce a result or update the variable.

Execution Sample

Java

int x = 5;
int y = ++x;
int z = x--;
System.out.println(x + "," + y + "," + z);

This code shows how prefix ++ and postfix -- unary operators change and use variable values.

Execution Table

Step	Expression	Variable x	Variable y	Variable z	Action	Output
1	int x = 5;	5	-	-	Initialize x to 5	-
2	int y = ++x;	6	6	-	Prefix ++ increments x to 6, then y = 6	-
3	int z = x--;	5	6	6	Postfix -- assigns z = 6, then decrements x to 5	-
4	System.out.println(x + "," + y + "," + z);	5	6	6	Print values of x, y, z	5,6,6

💡 All statements executed, program ends.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
x	-	5	6	5	5
y	-	-	6	6	6
z	-	-	-	6	6

Key Moments - 3 Insights

Why does x become 6 before y gets its value in ++x?

Because ++x is prefix increment, it increases x first (step 2), then assigns that new value to y.

Why does z get 6 but x becomes 5 after x--?

Because x-- is postfix decrement, it assigns the current x (6) to z first (step 3), then decreases x to 5.

What is the difference between prefix ++ and postfix -- in this example?

Prefix ++ changes the variable before using it, postfix -- uses the variable first then changes it, as shown in steps 2 and 3.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of x after step 3?

A 7

B 6

C 5

D 4

💡 Hint

Check the 'Variable x' column after step 3 in the execution_table.

At which step does y get its value assigned?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Look at the 'Action' column for when y is assigned in the execution_table.

If we change ++x to x++, what would be the value of y after step 2?

A 6

B 5

C 7

D 4

💡 Hint

Remember postfix ++ uses the original value before incrementing, check variable_tracker for x changes.

Concept Snapshot

Unary operators use one operand.
Prefix ++ or -- changes value before use.
Postfix ++ or -- uses value then changes it.
Common unary operators: ++, --, +, -, !
They can update variables or produce new values.

Full Transcript

This example shows unary operators in Java. We start with x = 5. Then ++x increases x to 6 before assigning to y, so y becomes 6. Next, x-- assigns current x (6) to z, then decreases x to 5. Finally, printing x, y, z shows 5,6,6. Prefix operators change the variable before use; postfix operators use the variable then change it. This helps understand how unary operators affect variables step-by-step.

Practice

1.

What does the unary operator ++ do in Java?

easy

A. Negates the value of a variable

B. Increases the value of a variable by 1

C. Decreases the value of a variable by 1

D. Checks if a value is true or false

Solution

1. Step 1: Understand the meaning of ++

   The ++ operator adds 1 to the current value of a variable.

2. Step 2: Compare with other unary operators

   -- subtracts 1, ! flips boolean, and negation changes sign.

3. Final Answer:

   Increases the value of a variable by 1 -> Option B

4. Quick Check:

   ++ means add one [OK]

Hint: ++ means add one to a number quickly [OK]

Common Mistakes:

• Confusing ++ with --
• Thinking ++ negates the value
• Mixing ++ with boolean negation !

2.

Which of the following is the correct **postfix** syntax to decrement a variable x by 1 using a unary operator?

int x = 5;
// Your code here

easy

A. x-1;

B. --x;

C. x--;

D. x=!1;

Solution

1. Step 1: Identify decrement unary operators

   Both x-- and --x decrement by 1, but x-1 is an expression, not an operator.

2. Step 2: Choose correct syntax for decrement

   x--; correctly decreases x by 1 after its current use.

3. Final Answer:

   x--; -> Option C

4. Quick Check:

   Use x-- to subtract one [OK]

Hint: Use x-- or --x to subtract one [OK]

Common Mistakes:

• Using x-1; which doesn't change x
• Confusing ! operator with decrement
• Writing invalid syntax like x=!1;

3.

What is the output of the following Java code?

int a = 3;
System.out.println(++a);
System.out.println(a++);
System.out.println(a);

medium

A. 4 4 5

B. 3 4 5

C. 4 3 4

D. 3 3 4

Solution

1. Step 1: Evaluate ++a

   ++a increases a before printing, so prints 4 and a becomes 4.

2. Step 2: Evaluate a++

   a++ prints current a (4) then increases it to 5.

3. Step 3: Print final value of a

   After previous steps, a is 5, so prints 5.

4. Final Answer:

   4 4 5 -> Option A

5. Quick Check:

   Prefix ++ adds before print, postfix ++ adds after print [OK]

Hint: Prefix ++ changes before print, postfix ++ after print [OK]

Common Mistakes:

• Mixing prefix and postfix effects
• Forgetting that ++ changes the variable
• Assuming no change in variable after print

4.

Find the error in the following code snippet:

boolean flag = true;
flag = !flag++;
System.out.println(flag);

medium

A. No error, code runs fine

B. Missing semicolon after flag declaration

C. Logical NOT operator ! cannot be used here

D. Cannot apply ++ to a boolean variable

Solution

1. Step 1: Check variable type and operators

   flag is boolean; ++ operator works only on numeric types, not boolean.

2. Step 2: Identify invalid operation

   Using flag++ causes a compile-time error because booleans cannot be incremented.

3. Final Answer:

   Cannot apply ++ to a boolean variable -> Option D

4. Quick Check:

   ++ works only on numbers, not booleans [OK]

Hint: ++ cannot be used on boolean variables [OK]

Common Mistakes:

• Trying to increment boolean values
• Confusing logical NOT ! with increment ++
• Assuming code compiles without error

5.

Given the code below, what will be the final value of count after execution?

int count = 0;
for (int i = 0; i < 3; i++) {
    count = count++ + ++count;
}
System.out.println(count);

hard

A. 14

B. 6

C. 12

D. 9

Solution

1. Step 1: Understand count = count++ + ++count; behavior

   Binary + evaluates left operand first (count++: old value then increment), then right (++count: increment then new value).

2. Step 2: Trace loop iterations

   Iteration 1 (count=0): count++ value=0 (count=1), ++count value=2, sum=2 -> count=2.
   Iteration 2 (count=2): count++=2 (count=3), ++count=4, sum=6 -> count=6.
   Iteration 3 (count=6): count++=6 (count=7), ++count=8, sum=14 -> count=14.

3. Step 3: Final value after loop

   After 3 iterations, count is 14.

4. Final Answer:

   14 -> Option A

5. Quick Check:

   Left-to-right: postfix old + prefix new [OK]

Hint: Left operand postfix (old then inc), right prefix (inc then new) [OK]

Common Mistakes:

• Assuming both increments add fully
• Ignoring postfix increment side effects
• Calculating sum without assignment effect