Non-nullable types by default in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does it mean that Kotlin has non-nullable types by default?

In Kotlin, variables cannot hold null unless explicitly declared. This helps prevent errors caused by null values, making programs safer.

beginner

How do you declare a variable that can hold null in Kotlin?

You add a question mark ? after the type. For example, var name: String? means name can be a string or null.

beginner

What happens if you try to assign null to a non-nullable variable in Kotlin?

The code will not compile. Kotlin forces you to handle nulls explicitly to avoid runtime errors.

beginner

Explain the difference between String and String? in Kotlin.

String cannot be null. String? can be null. You must check for null before using String? safely.

intermediate

What Kotlin feature helps you safely use nullable variables?

The safe call operator ?. lets you access properties or methods only if the variable is not null. Otherwise, it returns null.

In Kotlin, what does var age: Int mean?

A age cannot be null

B age can be null

C age is a nullable integer

D age is a string

Without a ?, the type is non-nullable, so age cannot be null.

How do you declare a nullable string in Kotlin?

A var name: ?String

B var name: String

C var name: String?

D var name: Nullable String

Adding ? after the type makes it nullable.

What operator helps safely access a property of a nullable variable?

A ?.

B !!

C ::

D ->

The safe call operator ?. returns null if the variable is null, avoiding errors.

What happens if you assign null to a non-nullable variable?

A Variable becomes null

B Variable is ignored

C Runtime exception

D Compilation error

Kotlin prevents this at compile time to avoid null pointer errors.

Which of these is a non-nullable type in Kotlin?

A Int?

B Int

C String?

D null

Int is non-nullable, while Int? can hold null.

Explain why Kotlin uses non-nullable types by default and how it helps programmers.

Think about how null values cause errors and how Kotlin stops that.

Describe how to safely work with a nullable variable in Kotlin.

Remember the special operator that helps avoid null problems.

Practice

1. In Kotlin, what happens if you declare a variable without a ? after its type?

easy

A. The variable cannot hold null values.

B. The variable can hold null values.

C. The variable is automatically initialized to null.

D. The variable must be declared as lateinit.

Solution

1. Step 1: Understand Kotlin's default type behavior

   Kotlin types are non-nullable by default, meaning variables cannot hold null unless specified.

2. Step 2: Check the effect of missing ?

   Without ?, the variable type is non-nullable, so it cannot hold null.

3. Final Answer:

   The variable cannot hold null values. -> Option A

4. Quick Check:

   Non-nullable type = no null allowed [OK]

Hint: No ? means no null allowed [OK]

Common Mistakes:

• Thinking variables are nullable by default
• Assuming variables initialize to null automatically
• Confusing lateinit with nullability

2. Which of the following Kotlin variable declarations is correct to allow null values?

easy

A. val name: String? = null

B. val name: String?

C. val name: String = null

D. val name: String = "null"

Solution

1. Step 1: Identify nullable type syntax

   Adding ? after the type allows the variable to hold null.

2. Step 2: Check initialization

   Nullable variables must be initialized or declared with null explicitly, so val name: String? = null is correct.

3. Final Answer:

   val name: String? = null -> Option A

4. Quick Check:

   Nullable type with ? and initialized to null [OK]

Hint: Use ? and initialize nullable variables [OK]

Common Mistakes:

• Declaring nullable without ?
• Not initializing nullable variables
• Assigning null to non-nullable types

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

fun main() {
    val text: String? = null
    println(text?.length ?: "No text")
}

medium

A. 0

B. Compilation error

C. null

D. No text

Solution

1. Step 1: Understand safe call operator usage

   The text?.length safely accesses length only if text is not null.

2. Step 2: Evaluate the Elvis operator

   Since text is null, text?.length is null, so the Elvis operator ?: returns "No text".

3. Final Answer:

   No text -> Option D

4. Quick Check:

   Safe call + Elvis operator returns fallback [OK]

Hint: Safe call with Elvis returns fallback if null [OK]

Common Mistakes:

• Expecting 0 instead of fallback string
• Confusing safe call with normal call
• Thinking code causes error due to null

4. Identify the error in this Kotlin code snippet:

fun main() {
    val number: Int = null
    println(number)
}

medium

A. Variable 'number' is not initialized.

B. Cannot assign null to a non-nullable type Int.

C. Missing semicolon after println statement.

D. Variable 'number' should be declared as var.

Solution

1. Step 1: Check variable type and assignment

   The variable 'number' is declared as non-nullable Int but assigned null, which is not allowed.

2. Step 2: Understand Kotlin null safety rules

   Non-nullable types cannot hold null, so this causes a compilation error.

3. Final Answer:

   Cannot assign null to a non-nullable type Int. -> Option B

4. Quick Check:

   Non-nullable types reject null assignments [OK]

Hint: Non-nullable types cannot be assigned null [OK]

Common Mistakes:

• Thinking semicolon is required
• Assuming var fixes null assignment
• Ignoring Kotlin's null safety

5. You have a nullable variable val input: String?. You want to print its length only if it is not null, otherwise print "Empty input". Which Kotlin code correctly does this?

hard

A. println(input.length ?: "Empty input")

B. println(input!!.length)

C. println(if (input != null) input.length else "Empty input")

D. println(input?.length)

Solution

1. Step 1: Understand nullable variable usage

   Since input can be null, we must check before accessing length.

2. Step 2: Evaluate each option

   println(input.length ?: "Empty input") is invalid because length is Int, not nullable, so Elvis operator on it is wrong.
   println(if (input != null) input.length else "Empty input") safely checks null and prints length or fallback.
   println(input!!.length) uses !! which throws exception if null.
   println(input?.length) prints null if input is null, not the string "Empty input".

3. Final Answer:

   println(if (input != null) input.length else "Empty input") -> Option C

4. Quick Check:

   Explicit null check with if-else for safe access [OK]

Hint: Use if-else to check null before accessing properties [OK]

Common Mistakes:

• Using !! and risking exceptions
• Misusing Elvis operator on non-nullable Int
• Printing null instead of fallback string