Variables (val, var) and null safety in Android Kotlin

Introduction

Variables store information your app uses. Kotlin helps keep your app safe by making sure variables are used correctly and not null by mistake.

When you want to store a value that does not change, like a user's name.

When you need to store a value that can change, like a score in a game.

When you want to avoid app crashes by safely handling variables that might be empty or missing.

When you want to clearly tell the app if a variable can be empty or must always have a value.

Syntax

Android Kotlin

val name: String = "Alice"
var score: Int = 0
var nickname: String? = null

val means the variable cannot change after it is set.

var means the variable can change its value.

Adding ? after the type means the variable can be null (empty).

Examples

This creates a variable city that cannot change and must always have a value.

Android Kotlin

val city: String = "Paris"

This creates a variable age that can change from 25 to 26.

Android Kotlin

var age: Int = 25
age = 26

This variable can start empty (null) and later get a value.

Android Kotlin

var middleName: String? = null
middleName = "Lee"

Sample App

This program shows how to use val and var variables. It also shows how a variable can be null and later get a value.

Android Kotlin

fun main() {
  val firstName: String = "John"
  var points: Int = 10
  var nickname: String? = null

  println("Name: $firstName")
  println("Points: $points")
  println("Nickname: $nickname")

  points = 15
  nickname = "Johnny"

  println("Updated Points: $points")
  println("Updated Nickname: $nickname")
}

Important Notes

Trying to change a val variable will cause an error.

Variables without ? cannot be null, so Kotlin helps prevent crashes.

Use ?. or ?: operators to safely work with nullable variables.

Summary

val is for values that do not change.

var is for values that can change.

Adding ? after a type means the variable can be null (empty).

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