Summary  
This chapter explains that in Kotlin, `if` is an expression that returns a value and can be used directly in assignments or larger expressions, including multi-line branches.  

General domain of usage  
Conditional logic in code (e.g., computing values or status messages)

## What Does "If as an Expression" Mean?

In Kotlin, the `if` statement is not just a control flow statement—it is also an **expression**. This means that `if` can return a value, just like a variable or a function call. You can assign the result of an `if` expression directly to a variable.

## How Is This Different from Java?

In Java and many other languages, `if` is only a statement. You cannot assign the result of an `if` directly to a variable. You must use extra lines of code to set the value:

```java
int max;
if (a > b) {
    max = a;
} else {
    max = b;
}
```

In Kotlin, you can do this in one step:

```kotlin
val max = if (a > b) a else b
```

## Why Is This Useful?

- Makes code shorter and clearer;
- Reduces the risk of mistakes by keeping related logic together;
- Encourages you to think in terms of expressions, not just actions.

## Using If as an Expression

You can use `if` anywhere a value is needed. For example, you can return the result of an `if` expression from a function, or use it as part of a larger calculation. Both the `then` and `else` branches must return a value.

```kotlin
val result = if (score >= 60) "Pass" else "Fail"
```

## Multi-Line If Expressions

If you need more logic in each branch, you can use curly braces. The last expression in each branch is the value returned:

```kotlin
val message = if (user.isLoggedIn) {
    println("Welcome back!")
    "User logged in"
} else {
    println("Please log in.")
    "User not logged in"
}
```

## Key Takeaways

- In Kotlin, `if` is an **expression** that produces a value;
- You can assign the result of an `if` expression to a variable;
- This feature leads to more concise and readable code.

Which statement about using `if` as an expression in Kotlin is true?

A beginner-friendly course introducing the essential control flow concepts in Kotlin. Learn how to make decisions, repeat actions, and structure your code using if, when, loops, and more. Each chapter features clear explanations, practical code examples, and a quiz to reinforce your understanding.

Learn the foundation of decision making in Kotlin: Boolean types, comparison operators, logical operators, and combining conditions.

Master the use of if and if–else expressions in Kotlin, including chaining, nesting, and using if as an expression.

Deepen your understanding of conditional logic in Kotlin by mastering the when expression. Learn to replace long if–else chains, use multiple conditions, ranges, and return values with when.