Kotlin - How to decide between “lateinit” and “nullable variable”?

Question

I am confuse for lateinit and nullable variable, which one to use for variable.

lateinit var c: String
var d: String? = null
c = \"UserDefinedTarget\"

// if         


        

Answer 1

It depends. Nullable variable means that variable can hold value or null. lateinit means that variable must be initialised later. It should be initialized before accessing it. If you attempt accessing uninitialized lateinit variable UninitializedPropertyAccessException will be thrown.

It's always better to avoid using nulls in your app. Nulls are evil. So if you can initialize variable in onCreate then it's better to use lateinit. Also if you use dependency injection in your app and fields should be injected it's also a valid case to use lateinit instead of handling nulls.

If for some reason you can't initialize variable, initializing code can result to null, or null can be assigned to this variable later than you should use nullable variable. Generally speaking if null is a valid value for the variable.

Answer 2

A type that is nullable is just that, a thing that has a valid state that is null.

A non-nullable late init var represents something where null is an invalid state, but for some reason you can't populate it in the constructor.

Android Activities are a good example of a use of lateinit. Activities must have a no args constructor and their lifecycle only really starts with onCreate().

Answer 3

These are two completely different concepts.

You can use lateinit to avoid null checks when referencing the property. It's very convenient in case your properties are initialized through dependency injection, or, for example, in the setup method of a unit test.

However, you should keep in mind that accessing a lateinit property before it has been initialized throws an exception. That means you should use them only if you are absolutely sure, they will be initialized.

Nullable types, on the other hand, are used when a variable can hold null.

---

class A {
    lateinit var a: String

    fun cat() {
        print(a.length)  // UninitializedPropertyAccessException is thrown
        a = "cat"
        print(a.length)  // >>> 3
    }
}

class B {
    var b: String? = null

    fun dog() {
        print(b.length)  // won't compile, null check is obligatory here
        print(b?.length) // >>> null
        b = "dog"
        print(b?.length) // >>> 3
    }
}

---

For more information:

• Late-initialized properties
• Nullable types

Answer 4

Use lateinit for properties that cannot be initialized in a constructor.