Nullable Variable

A nullable variable in Kotlin is a variable whose type explicitly permits the assignment of a null reference. Kotlin’s type system strictly distinguishes between references that can hold null (nullable types, denoted as T?) and those that cannot (non-nullable types, denoted as T), enforcing null safety at compile-time to prevent runtime NullPointerExceptions.

To declare a nullable variable, append a question mark (?) to the base type declaration.

var nonNullableString: String = "Hello"
// nonNullableString = null // Compilation error

var nullableString: String? = "Hello"
nullableString = null // Valid assignment

Because a nullable variable T? acts as a union type of T | null, the Kotlin compiler prohibits direct access to the underlying T member properties or functions. However, direct access is permitted for extension functions or properties explicitly defined on the nullable type T? (such as nullableString.isNullOrEmpty() or nullableString.toString()). To access members of the underlying T type, you must explicitly resolve the nullability using one of Kotlin’s built-in operators or control flow mechanisms.

Safe Call Operator (?.)

The safe call operator evaluates the expression if the variable is not null. If the variable is null, the entire expression short-circuits and evaluates to null.

val length: Int? = nullableString?.length

Elvis Operator (?:)

The Elvis operator unwraps a nullable variable by providing a default non-null fallback value. If the expression on the left is not null, it returns that value; otherwise, it returns the expression on the right.

val length: Int = nullableString?.length ?: 0

Not-Null Assertion Operator (!!)

The not-null assertion operator forcefully casts a nullable type T? to a non-nullable type T, bypassing the compiler’s null safety checks. If the variable holds a null value at runtime, this operator explicitly throws a NullPointerException.

val length: Int = nullableString!!.length

Smart Casting

When a nullable variable is explicitly checked against null using standard conditional logic, the Kotlin compiler tracks this state and automatically “smart casts” the variable to its non-nullable counterpart within the scope of that check.

if (nullableString != null) {
    // The compiler smart-casts String? to String
    val length: Int = nullableString.length 
}

Limitation: Smart casts are strictly limited to variables where the compiler can guarantee the reference has not been modified by another thread or scope between the null check and the usage. Consequently, smart casting does not work on mutable class-level properties (var) or local var declarations that are captured and modified within lambdas.

Safe Unwrapping with ?.let

The let scope function, combined with the safe call operator (?.let), is a fundamental and idiomatic mechanism for safely unwrapping a nullable variable. It executes the provided lambda block only if the variable is not null, exposing a non-nullable reference (defaulting to it) inside the block. This pattern serves as the primary workaround for the smart casting limitations on mutable properties.

var mutableNullableString: String? = "Kotlin"

// Bypasses smart cast limitations by capturing the non-null value in a local scope
mutableNullableString?.let { nonNullString ->
    val length: Int = nonNullString.length
}

Safe Cast Operator (as?)

When casting types, the safe cast operator attempts to cast a variable to a target type. If the variable is not of the target type, it returns null instead of throwing a ClassCastException, resulting in a nullable variable.

val anyValue: Any = "Kotlin"
val number: Int? = anyValue as? Int // Evaluates to null

Master Kotlin with Deep Grasping Methodology!

Learn More