Kotlin: Property Must Be Initialized or Be Nullable

In the Kotlin programming language, properties need to be well-handled to avoid potential runtime errors. Specifically, Kotlin enforces non-nullable properties to be initialized before they are accessed. If a property cannot be initialized in the constructor or at the moment of declaration, you must make it nullable. This ensures that you handle situations where a property might not hold a default or initial value at the point of creation.

Understanding Property Initialization

Kotlin differentiates between nullable and non-nullable types, ensuring that any property declared must either be initialized immediately or be explicitly marked as nullable.

var name: String = "John Doe"  // Non-nullable and initialized immediately

If for any reason you cannot set an initial value for a variable, you must declare it as a nullable type using a question mark ? after the type:

var address: String?  // Nullable, can potentially be null

In the above code, if you try to use name without an initial assignment, it would result in a compilation error, ensuring early error detection.

Using Late Initialization – lateinit

In some cases, properties might not have an initial value at the time of class instantiation, but you know they will be established before use. Kotlin provides the lateinit modifier for such properties, applicable only to mutable types and cannot be used with nullable properties or primitive types.

data class User(var id: Int) {
    lateinit var nickname: String

    fun setNickname(nick: String) {
        nickname = nick
    }
}

You must ensure that the lateinit property is initialized before use to avoid UninitializedPropertyAccessException:

val user: User = User(123)
user.setNickname("Johnny")  // Initializes nickname before access
println(user.nickname)  // Now prints "Johnny"

Summary Table

Here’s a quick comparison of how you might decide to initialize your Kotlin properties:

Final Thoughts

Kotlin's approach to property initialization emphasizes code safety and consistency. Adopting these practices minimizes runtime errors and makes your programs more reliable and maintainable. Choose the appropriate initialization strategy for your properties based on their intended use and application lifecycle requirements.