Null Safety in Kotlin

# CHAPTER 12

Null Safety in Kotlin #

1. Chapter Introduction #

2. Learning Objectives #

• Distinguish between Non-Null and Nullable types (?).

• Understand why the compiler blocks null assignments.

• Safely access properties of nullable objects using ?..

• Provide default values using the Elvis operator ?:.

• Understand the dangers of the Not-Null Assertion !!.

3. The Non-Null Default #

fun main() {
    var name: String = "Alice"
    
    // name = null // COMPILER ERROR: Null can not be a value of a non-null type String
}

Because the compiler guarantees name is never null, you can safely call name.length without ever worrying about a crash.

4. Nullable Types (?) #

fun main() {
    var middleName: String? = "Marie" // String? means it can be a String OR null
    
    middleName = null // This is now perfectly legal!
}

5. The Compile-Time Check #

var middleName: String? = null

// println(middleName.length) // COMPILER ERROR: Only safe (?.) or non-null asserted (!!.) calls are allowed

The compiler mathematically prevents the Null Pointer Exception by forcing you to handle the potential null before the app even runs.

6. The Safe Call Operator (?.) #

fun main() {
    var middleName: String? = null
    
    // Safely requests the length. If null, it just returns the word 'null'.
    println(middleName?.length) // Output: null
    
    middleName = "Marie"
    println(middleName?.length) // Output: 5
}

7. The Elvis Operator (?:) #

fun main() {
    var middleName: String? = null
    
    // If middleName is null, the length is safe-called as null.
    // The Elvis operator catches that null and provides 0 instead!
    val length = middleName?.length ?: 0
    
    println("Middle name length is: $length") // Output: 0
}

8. The Not-Null Assertion (!!) (DANGER!) #

WARNING: If you use !! and the variable actually *is* null, the application will crash with a NullPointerException (NPE)!

var name: String? = null

// println(name!!.length) // CRASH! DO NOT DO THIS!

*Rule of thumb: Try to never use !! in production code. It defeats the entire purpose of Kotlin's safety.*

9. Mini Project: Safe User Profile #

fun main() {
    val username: String = "AdminUser" // Guaranteed to exist
    val bio: String? = null            // Might be missing
    
    println("User: $username")
    
    // Safely print the bio or a default message
    val displayBio = bio ?: "This user has not set a biography."
    println("Bio: $displayBio")
    
    // Safely calculate length
    val bioLength = bio?.length ?: 0
    println("Bio Length: $bioLength characters")
}

10. Common Mistakes #

• Using !! to bypass compiler errors: Beginners often use !! when the compiler complains about a nullable type, just to make the red squiggly line go away. This brings Java's NPEs straight back into your code. Use ?. instead!

11. Best Practices #

• Embrace ?. and ?:: Chaining safe calls is idiomatic Kotlin. You can chain them deeply: user?.department?.manager?.name ?: "No Manager". This replaces dozens of lines of if (user != null) checks in Java.

12. Exercises #

1. 1. Declare a nullable String city and assign it null.

1. 2. Use the safe call operator to print the uppercase version of city.

1. 3. Use the Elvis operator to print "Unknown City" if city is null.

13. MCQs with Answers #

Q1. By default, can a Kotlin variable hold a null value? a) Yes b) No, standard types are non-null by default Answer: b) No, they are non-null by default.

14. Interview Questions #

• Q: Explain how Kotlin prevents NullPointerExceptions at compile time.

• Q: If you have a chain like company?.ceo?.name, what happens if company is null? (Answer: The entire chain immediately evaluates to null. It does not attempt to access .ceo, preventing a crash).

15. Summary #

16. Next Chapter Recommendation #