Skip to content

An Overview of Null Checks in Kotlin

Kotlin, Null Safety, Android Development2 min read

When working with programming languages, null references can often lead to unexpected crashes or bugs. Kotlin, a modern programming language widely used for Android app development, provides built-in null safety features that help prevent these issues. In this article, we'll delve into the topic of null checks in Kotlin and discuss how they enhance the robustness of your code.

Nullable Types

In Kotlin, variables must explicitly declare whether they can hold null values using the nullable type syntax. By appending a ? to the type declaration, you indicate that the variable can either contain a non-null value of that type or be null. For example:

1val name: String? = null

In the above code snippet, the variable name is declared as a nullable String type, allowing it to hold a string value or be assigned null.

Safe Calls

To safely access properties or call functions on nullable objects, Kotlin provides the safe call operator (?.). This operator ensures that the code gracefully handles null values without throwing a NullPointerException. Consider the following example:

1val length: Int? = name?.length

Here, the safe call operator ?. is used to access the length property of the name variable. If name is null, the expression evaluates to null instead of throwing an exception, preventing potential crashes.

Elvis Operator

The Elvis operator (?:) in Kotlin provides a concise way to handle null values by providing a default value when the expression on the left side is null. It is often used in cases where you want to assign a non-null value if the original value is null. Take a look at this example:

1val message: String = name ?: "Guest"

In the above code, if name is not null, it will be assigned to the message variable. However, if name is null, the string "Guest" will be used as the default value.

Safe Casts

When dealing with nullable types, Kotlin enables safe type casts using the safe cast operator (as?). This operator attempts to cast an object to the specified type and returns null if the cast fails. Here's an example:

1val length: Int? = name as? String?.length

In the above code snippet, the safe cast operator as? is used to attempt casting the name variable to a String type. If the cast succeeds, the length of the string is assigned to length. Otherwise, if the cast fails, length will be null.

Not-null Assertion

In certain scenarios, you might have knowledge that a variable cannot hold a null value, even though its type is nullable. In such cases, you can use the not-null assertion operator (!!) to explicitly tell the compiler that the value will never be null. However, incorrect usage of this operator can result in a NullPointerException, so caution is advised when using it.

1val length: Int = name!!.length

In the above code, the not-null assertion operator !! is used to assert that name is not null. If name happens to be null, a NullPointerException will be thrown.

In Closing

Null checks play a crucial role in Kotlin programming, ensuring code reliability and preventing common null-related issues. By leveraging features such as safe calls, the Elvis operator, safe casts, and not-null assertions, Kotlin empowers developers to write more robust and less error-prone code. This article merely scratched the surface of null checks in Kotlin, but it should serve as a solid starting point for understanding and utilizing these powerful language features.