Variables (val, var) and null safety in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

📝 Syntax

intermediate

Understanding val and var declaration

What will be the output of this Kotlin code snippet?

val x = 10
var y = 5
y = 7
println("x = $x, y = $y")

Android Kotlin

val x = 10
var y = 5
y = 7
println("x = $x, y = $y")

A x = 10, y = 7

B x = 10, y = 5

C x = 7, y = 7

D Compilation error

💡 Hint

Remember val means constant, var means variable.

val declares a read-only variable, so x cannot be changed. var declares a mutable variable, so y can be reassigned.

❓ ui_behavior

intermediate

Null safety with nullable types

What will happen when this Kotlin code runs?

var name: String? = null
println(name?.length)

Android Kotlin

var name: String? = null
println(name?.length)

A Throws NullPointerException

B Prints 0

C Compilation error

D Prints null

💡 Hint

The ?. operator safely accesses properties of nullable variables.

The safe call operator ?. returns null if the variable is null, so name?.length prints null safely.

❓ lifecycle

advanced

Lateinit var usage and initialization

What error will this Kotlin code cause when run?

lateinit var message: String
println(message)

Android Kotlin

lateinit var message: String
println(message)

A Prints null

B Prints empty string

C Throws UninitializedPropertyAccessException

D Compilation error

💡 Hint

Lateinit variables must be initialized before use.

Accessing a lateinit var before initialization throws UninitializedPropertyAccessException at runtime.

🔧 Debug

advanced

Null safety and !! operator behavior

What happens when this Kotlin code runs?

var text: String? = null
println(text!!.length)

Android Kotlin

var text: String? = null
println(text!!.length)

A Throws KotlinNullPointerException

B Prints 0

C Prints null

D Compilation error

💡 Hint

The !! operator asserts non-null and throws if null.

Using !! on a null variable throws KotlinNullPointerException at runtime.

🧠 Conceptual

expert

Choosing val or var for thread safety

In a multi-threaded Android app, which variable declaration is safer to avoid unexpected changes?

val data = mutableListOf()
var data = mutableListOf()

A var because it allows changing the list reference safely

B val because it prevents reassignment but list contents can still change

C val because it makes the list immutable

D var because it prevents concurrent modification exceptions

💡 Hint

val prevents changing the reference but does not make the object immutable.

val prevents the variable from pointing to a different list, but the list itself can still be modified, so thread safety depends on synchronization, not val/var alone.

Practice

1. Which keyword should you use in Kotlin for a variable whose value will never change after assignment?

easy

A. let

B. var

C. val

D. const

Solution

1. Step 1: Understand Kotlin variable keywords

   val is used for read-only variables, meaning their value cannot change once assigned.

2. Step 2: Compare with other keywords

   var allows changing the value; const is not a Kotlin keyword for variables; let is from other languages like Swift or JavaScript.

3. Final Answer:

   val -> Option C

4. Quick Check:

   Immutable variable = val [OK]

Hint: Use val for fixed values, var for changeable ones [OK]

Common Mistakes:

• Confusing val and var
• Using const which is not Kotlin variable keyword
• Thinking let is Kotlin keyword

2. Which of the following is the correct way to declare a nullable String variable in Kotlin?

easy

A. var name: String? = null

B. var name: String?

C. var name: String = null

D. var name: String = "null"

Solution

1. Step 1: Understand nullable type syntax

   In Kotlin, adding ? after the type means the variable can hold null.

2. Step 2: Check initialization

   Nullable variables should be initialized with null if no value is assigned yet.

3. Final Answer:

   var name: String? = null -> Option A

4. Quick Check:

   Nullable variable syntax = var name: String? = null [OK]

Hint: Use ? after type and assign null to allow null values [OK]

Common Mistakes:

• Assigning null to non-nullable type
• Forgetting ? for nullable types
• Using string "null" instead of null

3. What will be the output of this Kotlin code?

var count: Int? = 5
count = null
println(count)

medium

A. null

B. 0

C. 5

D. Compilation error

Solution

1. Step 1: Analyze variable declaration

   count is declared as nullable Int (Int?) and initially set to 5.

2. Step 2: Assign null and print

   Then count is assigned null, which is allowed for nullable types, so printing it outputs null.

3. Final Answer:

   null -> Option A

4. Quick Check:

   Nullable variable assigned null prints null [OK]

Hint: Nullable variables can hold null and print it directly [OK]

Common Mistakes:

• Expecting 5 after reassignment
• Thinking null prints 0
• Assuming compilation error for null assignment

4. Identify the error in this Kotlin code snippet:

val message: String = null
println(message)

medium

A. No error, code runs fine

B. val cannot be used with String type

C. println cannot print val variables

D. Cannot assign null to non-nullable type String

Solution

1. Step 1: Check variable type and assignment

   message is declared as non-nullable String but assigned null, which is not allowed.

2. Step 2: Understand Kotlin null safety rules

   Non-nullable types cannot hold null; to allow null, type must be String?.

3. Final Answer:

   Cannot assign null to non-nullable type String -> Option D

4. Quick Check:

   Non-nullable String cannot be null [OK]

Hint: Non-nullable types cannot hold null values [OK]

Common Mistakes:

• Thinking val disallows null but var allows
• Assuming println can't print val
• Ignoring Kotlin's null safety rules

5. You want to create a variable that can change its value but sometimes hold no value at all. Which declaration is correct in Kotlin?

hard

A. val data: Int = null

B. var data: Int? = null

C. val data: Int? = 0

D. var data: Int = null

Solution

1. Step 1: Understand mutability and nullability

   The variable must be changeable, so var is needed, and it must allow null, so type must be nullable with ?.

2. Step 2: Check each option

   val data: Int = null uses val (immutable) and assigns null to non-nullable type (error). var data: Int? = null uses var and nullable type with null initial value (correct). val data: Int? = 0 uses val (immutable) but nullable type with 0 initial value (not changeable). var data: Int = null uses var but non-nullable type assigned null (error).

3. Final Answer:

   var data: Int? = null -> Option B

4. Quick Check:

   Mutable and nullable = var with ? [OK]

Hint: Use var for changeable and ? for nullable types [OK]

Common Mistakes:

• Using val when variable should change
• Assigning null to non-nullable type
• Confusing val and var usage