Variables, Data Types, and Operators in Kotlin

# CHAPTER 4

Variables, Data Types, and Operators in Kotlin #

1. Introduction #

2. Learning Objectives #

• Understand and utilize the difference between Mutable (var) and Immutable (val) variables.

• Explicitly declare data types (Int, Double, Boolean, String).

• Perform mathematical operations using Arithmetic Operators.

• Execute Type Conversions safely.

3. The Golden Rule: val vs var #

var (Variable / Mutable): The data inside this box CAN be changed later.

fun main() {
    var playerHealth = 100
    println(playerHealth) // Prints 100
    
    // The player takes damage! We change the variable.
    playerHealth = 80 
    println(playerHealth) // Prints 80
}

val (Value / Immutable): The data inside this box is LOCKED. It can NEVER be changed once assigned. It is a "constant".

fun main() {
    val maxPlayers = 4
    // maxPlayers = 5 // FATAL ERROR: "Val cannot be reassigned!"
}

*Best Practice Rule:* ALWAYS use val unless you are absolutely certain the variable needs to change in the future. This prevents massive bugs where data is accidentally overwritten!

4. Explicit Data Types #

• Int: Whole numbers (e.g., 10, -500)

• Double: Decimal numbers (e.g., 3.14, 99.99)

• Boolean: True or False flags.

• String: Text wrapped in double quotes.

fun main() {
    // Explicit Type Declaration
    val age: Int = 25
    val price: Double = 19.99
    val isGameOver: Boolean = false
    val username: String = "AdminUser"
}

5. Type Conversion #

fun main() {
    val stringNumber = "50"
    
    // val total = stringNumber + 10 // ERROR! Cannot add String and Int!
    
    // 1. Convert the String into a real Integer!
    val realNumber = stringNumber.toInt() 
    
    // 2. Now the math works!
    val total = realNumber + 10 
    println(total) // Prints 60
}

6. Arithmetic Operators #

• Addition: +

• Subtraction: -

• Multiplication: *

• Division: /

• Modulus (Remainder): %

fun main() {
    var gold = 100
    
    // Standard Math
    gold = gold + 50 
    
    // Shorthand Math (Does the exact same thing, but faster to type!)
    gold += 50  
    
    // Increment by exactly 1
    gold++      
}

7. Logical Operators #

• && (AND): Both sides must be true.

• || (OR): Only one side needs to be true.

• ! (NOT): Reverses the boolean (True becomes False).

fun main() {
    val hasKey = true
    val doorIsUnlocked = false
    
    // OR Operator: Can we open the door?
    val canEnter = hasKey || doorIsUnlocked 
    println("Can enter? $canEnter") // Prints true (because hasKey is true!)
}

8. Mini Project: Character Stats #

fun main() {
    // Immutable stats (These never change!)
    val characterName: String = "Eldoria"
    val characterClass: String = "Mage"
    
    // Mutable stats (These change during gameplay!)
    var level: Int = 1
    var experiencePoints: Double = 0.0
    var isAlive: Boolean = true
    
    // Simulating combat
    println("--- BATTLE START ---")
    println("$characterName the $characterClass attacks!")
    
    // Gaining XP
    experiencePoints += 45.5
    
    // Leveling up
    level++
    
    println("Battle Won! Current XP: $experiencePoints")
    println("Level Up! You are now level $level.")
}

9. Common Mistakes #

• Integer Division: If you divide two Int variables in Kotlin (e.g., val result = 5 / 2), the answer will be 2, NOT 2.5. Because both numbers are Integers, Kotlin chops off the decimal! To get a decimal answer, at least one number must be a Double (e.g., val result = 5.0 / 2).

• Reassigning val: Beginners often use val everywhere because it's shorter to type, and then get frustrated when the compiler throws errors when they try to update a score counter. Remember: val = Locked. var = Changeable.

10. Best Practices #

• Prefer val Over var: In enterprise Android engineering, mutability (data changing) is the number one cause of unpredictable bugs. If you create a variable that just holds a downloaded URL, and it never needs to change, it MUST be a val. Only elevate it to var if the application logic strictly demands mutation.

11. Exercises #

1. 1. Declare a mutable variable named temperature and explicitly assign it a Double data type with a value of 98.6.

1. 2. Change the value of temperature to 100.2.

12. Coding Challenges #

13. MCQ Quiz with Answers #

14. Interview Questions #

• Q: Explain the paradigm of "Immutability" in software engineering. Why does Kotlin heavily encourage developers to default to val instead of var?

• Q: Describe the behavior of Integer Division in Kotlin. If you execute val ratio = 10 / 3, what is the exact data type and value assigned to ratio, and why?

• Q: Contrast the Explicit Data Type declaration (val age: Int = 10) with Type Inference (val age = 10). In what specific architectural scenario might Explicit Declaration be absolutely mandatory?

15. FAQs #

16. Summary #

17. Next Chapter Recommendation #