Variables and Data Types

# CHAPTER 4

Variables and Data Types #

1. Chapter Introduction #

2. Learning Objectives #

• Declare mutable variables using the var keyword.

• Declare read-only (immutable) variables using the val keyword.

• Understand Immutability and why it is preferred.

• Leverage Type Inference.

• Identify Kotlin's fundamental data types.

3. Declaring Variables (val vs var) #

#### var (Variable - Mutable) Use var if you expect the value of the variable to change later in the program.

fun main() {
    var score = 10
    println("Initial score: $score")
    
    score = 20 // We can change this because it is a 'var'
    println("New score: $score")
}

#### val (Value - Immutable / Read-Only) Use val if the value should never change once it is assigned. It is the equivalent of a final variable in Java or const in JavaScript.

fun main() {
    val birthYear = 1995
    println("Birth Year: $birthYear")
    
    // birthYear = 1996 // ERROR: Val cannot be reassigned!
}

Best Practice: Always default to using val. Only change it to var if you absolutely need to modify the data later. Immutable variables make your code safer, easier to debug, and thread-safe.

4. Type Inference (The Smart Compiler) #

val name = "Alice"   // The compiler knows this is a String
val age = 28         // The compiler knows this is an Int
val isStudent = true // The compiler knows this is a Boolean

5. Explicit Type Declaration #

fun main() {
    val city: String // Explicit type declaration
    
    // ... some code happens ...
    
    city = "New York" // First assignment is valid for val
    println(city)
}

6. Basic Data Types #

#### 1. Numbers (Integers)

• Byte: 8-bit

• Short: 16-bit

• Int: 32-bit (Default for whole numbers)

• Long: 64-bit (Add an 'L' to the end of the number: val billion = 1000000000L)

#### 2. Numbers (Floating Point)

• Float: 32-bit (Add an 'f' or 'F': val weight = 70.5f)

• Double: 64-bit (Default for decimal numbers: val pi = 3.14159)

#### 3. Booleans Can only be true or false.

val isOnline: Boolean = true

#### 4. Characters Represents a single character enclosed in single quotes.

val letter: Char = 'A'

#### 5. Strings Represents text, enclosed in double quotes.

val greeting: String = "Hello, Kotlin!"

7. Type Conversion #

fun main() {
    val smallNumber: Int = 100
    
    // val largeNumber: Long = smallNumber // ERROR! Type mismatch
    
    // CORRECT: Use explicit conversion
    val largeNumber: Long = smallNumber.toLong()
    
    val decimal: Double = smallNumber.toDouble()
}

Available functions: toByte(), toShort(), toInt(), toLong(), toFloat(), toDouble(), toString().

8. Common Mistakes #

• Trying to reassign a val: This is the most common beginner error. If the compiler says "val cannot be reassigned", change the keyword to var (or better yet, rethink your logic!).

• Forgetting the 'f' for Floats: val weight: Float = 70.5 will cause an error because 70.5 is inferred as a Double. It must be 70.5f.

9. Best Practices #

• Favor Immutability: Write programs with as many val variables as possible. This is a core philosophy of modern JVM development.

• Let the compiler do the work: Don't write val name: String = "Bob". Just write val name = "Bob". Rely on Type Inference to keep code clean.

10. Exercises #

1. 1. Declare a read-only variable company and set it to your dream company.

1. 2. Declare a mutable variable yearsWorked and set it to 0.

1. 3. Increment yearsWorked to 1.

1. 4. Print both variables using println().

11. MCQs with Answers #

12. Interview Questions #

• Q: Explain the difference between var and val in Kotlin. Which one corresponds to Java's final keyword?

• Q: What is Type Inference in Kotlin, and how does it differ from a dynamically typed language like JavaScript? (Answer: Kotlin determines the type at *compile time* and strictly locks it. JavaScript determines it at runtime and allows the type to change completely).

13. Summary #

14. Next Chapter Recommendation #