Operator precedence in Kotlin - Step-by-Step Execution

Concept Flow - Operator precedence

Start Expression

↓

Identify Operators

↓

Check Precedence

↓

Evaluate Highest Precedence Operator

↓

Replace with Result

↓

More Operators?

Yes→Repeat Check Precedence

No↓

Final Result

The program reads an expression, finds operators, evaluates them by precedence order, and repeats until the final result is computed.

Execution Sample

Kotlin

val result = 3 + 4 * 2
println(result)

Calculates 3 plus 4 times 2, showing how multiplication happens before addition.

Execution Table

Step	Expression	Operator Evaluated	Operation	Result
1	3 + 4 * 2	*	4 * 2	8
2	3 + 8	+	3 + 8	11
3	11	None	Final result	11

💡 No more operators left, final result is 11

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
result	undefined	undefined	undefined	11

Key Moments - 2 Insights

Why does multiplication happen before addition?

Because multiplication has higher precedence than addition, as shown in execution_table step 1 where '*' is evaluated before '+'.

What if we want addition first?

We use parentheses to change precedence, e.g. (3 + 4) * 2, which forces addition before multiplication.

Visual Quiz - 3 Questions

Look at the execution_table, what is the result after step 1?

A 6

B 8

C 11

D 14

💡 Hint

Check the 'Result' column in execution_table row for step 1.

At which step is the addition operator '+' evaluated?

A Step 1

B Step 3

C Step 2

D Never

💡 Hint

Look at the 'Operator Evaluated' column in execution_table.

If the expression was (3 + 4) * 2, what would be the final result?

A 14

B 11

C 10

D 8

💡 Hint

Parentheses change precedence, so addition happens first: 3+4=7, then 7*2=14.

Concept Snapshot

Operator precedence decides which operator runs first in expressions.
Multiplication (*) and division (/) have higher precedence than addition (+) and subtraction (-).
Use parentheses () to change the order.
Kotlin evaluates operators from highest to lowest precedence step-by-step.

Full Transcript

Operator precedence in Kotlin means some operations happen before others in an expression. For example, multiplication happens before addition. In the code 'val result = 3 + 4 * 2', Kotlin first calculates 4 times 2, then adds 3. This is because '*' has higher precedence than '+'. If you want addition first, use parentheses like '(3 + 4) * 2'. The execution table shows each step: first multiply, then add, then get the final result. Variables update only after all operations finish. Remember, parentheses can change the order to what you want.

Practice

1. In Kotlin, which operator has the highest precedence in the expression 3 + 4 * 2?

easy

A. Multiplication (*)

B. Addition (+)

C. Subtraction (-)

D. Division (/)

Solution

1. Step 1: Identify operators in the expression

   The expression has addition (+) and multiplication (*).

2. Step 2: Recall operator precedence rules

   Multiplication (*) has higher precedence than addition (+), so it runs first.

3. Final Answer:

   Multiplication (*) -> Option A

4. Quick Check:

   Multiplication before addition = Multiplication (*) [OK]

Hint: Multiply and divide before adding or subtracting [OK]

Common Mistakes:

• Thinking addition runs before multiplication
• Ignoring operator precedence
• Assuming left to right always applies

2. Which of the following Kotlin expressions correctly uses parentheses to change the order of operations in 3 + 4 * 2 so that addition happens first?

easy

A. 3 + (4 * 2)

B. (3 + 4) * 2

C. 3 + 4 * 2

D. 3 * (4 + 2)

Solution

1. Step 1: Understand default precedence

   Without parentheses, multiplication runs before addition.

2. Step 2: Check which option forces addition first

   (3 + 4) * 2 uses parentheses around (3 + 4), so addition happens before multiplication.

3. Final Answer:

   (3 + 4) * 2 -> Option B

4. Quick Check:

   Parentheses change order = (3 + 4) * 2 [OK]

Hint: Use parentheses to force addition before multiplication [OK]

Common Mistakes:

• Ignoring parentheses effect
• Choosing expression without parentheses
• Assuming left to right overrides precedence

3. What is the output of this Kotlin code?

val result = 10 - 4 + 2 * 3
println(result)

medium

A. 12

B. 18

C. 14

D. 4

Solution

1. Step 1: Apply operator precedence

   Multiplication (*) runs first: 2 * 3 = 6.

2. Step 2: Evaluate remaining expression left to right

   10 - 4 + 6 = 6 + 6 = 12.

3. Final Answer:

   12 -> Option A

4. Quick Check:

   Multiplication before addition/subtraction = 12 [OK]

Hint: Multiply before adding or subtracting [OK]

Common Mistakes:

• Adding before multiplying
• Calculating left to right ignoring precedence
• Miscomputing subtraction and addition order

4. Find the error in this Kotlin expression:

val x = 5 + 3 * 2 && true

What is the problem?

medium

A. Logical AND (&&) has higher precedence than multiplication

B. Missing semicolon at the end

C. Multiplication operator is invalid here

D. Cannot mix arithmetic and boolean operators without parentheses

Solution

1. Step 1: Identify mixed types in expression

   The expression mixes arithmetic (5 + 3 * 2) and boolean (&& true) without separation.

2. Step 2: Understand Kotlin type rules

   You cannot combine Int and Boolean directly without explicit logic or parentheses.

3. Final Answer:

   Cannot mix arithmetic and boolean operators without parentheses -> Option D

4. Quick Check:

   Mixing Int and Boolean needs care [OK]

Hint: Don't mix numbers and booleans without clear separation [OK]

Common Mistakes:

• Thinking semicolon is missing
• Assuming && works with numbers
• Ignoring type mismatch errors

5. Given the Kotlin expression:

val result = true || false && false || true && false

What is the value of result considering operator precedence?

hard

A. false

B. Syntax error

C. true

D. null

Solution

1. Step 1: Recall logical operator precedence

   Logical AND (&&) has higher precedence than OR (||), so evaluate && first.

2. Step 2: Evaluate all AND operations

   false && false = false, true && false = false.

3. Step 3: Replace and evaluate OR operations left to right

   true || false || false = true || false = true.

4. Final Answer:

   true -> Option C

5. Quick Check:

   AND before OR, final result true [OK]

Hint: Evaluate && before || in logical expressions [OK]

Common Mistakes:

• Evaluating OR before AND
• Confusing operator precedence
• Assuming expression returns null or error