在函数中声明 val 而不初始化

Question

class Solution { 
    val message: String  //error : val must be initialized or abstract
    message = "love" //error : val cannot be reassigned
}

I understand what's happening in here - val cannot be reassigned.
So when I need val but can not initialize it i used to use by lazy

class Solution {
    fun love(){
        val message : String
        message = "love"   //this works
        message = "hate"   //this is error "val cannot be reassigned"
    }
}

Here I can delcare val without initialization and later write code message = "love" .what's happening here?

Answer 1

@deHaar noticed correctly that only var (mutable variable) is appropriate in your case.

The error you get is absolutely correct and expected.

what's happening here?

When you declare a read-only variable without initializing it you have to make sure that each execution path will have a value in this read-only variable. It means that Kotlin makes sure if your read-only variable was or was not initialized in every place it is used and raises errors if the variable is used inappropriately.

Here you have only one execution path as there are no when or if statements that can split execution into several possible paths.

class Solution {
    fun love(){
        val message : String
        message = "love"   // Kotlin knows that `message` was not yet initialized
        message = "hate"   // Kotlin knows that `message` was yet initialized! It does not allow to modify the value.
    }
}

Here is what Kotlin documentation says:

... it is also possible (but discouraged) to split the declaration and the initial assignment, and even to initialize in multiple places based on some condition. You can only read the variable at a point where the compiler can prove that every possible execution path will have initialized it. If you're creating a read-only variable in this way, you must also ensure that every possible execution path assigns to it exactly once.

Example of an execution path

Using when or if statement you create two or more execution paths. Execution paths can be presented as a graph, I'll use #number as a node number . Example:

class Solution {
    fun love(){
        // #1
        val message : String
        if (System.currentTimeMillisec() % 2 == 0) {
            message = "Not empty"      
            // #2
        }

        if (message.isEmpty) { // Error! Message could be not initialized at this point! 
            println("Empty message")
            // #3
        }
    }
}

Looking at this example, that does not compile , we can calculate at least 3 execution paths.

1. #1 (none of the if statements was entered. All conditions are false )
2. #1 -> #2
3. #1 -> #3

Kotlin can calculate these paths and check if the message variable is initialized in every path it is used. As we can see, as soon as you reach the evaluation of the second if statement (in case of first and third paths) your program will crash because the message has no value. It has no address in memory and a computer which runs this program does not know how to get a value from an address that does not exist.

Now, let's modify this code to make it work:

class Solution {
    fun love(){
        // #1
        val message : String
        if (System.currentTimeMillisec() % 2 == 0) {
            message = "Not empty"      
            // #2
        } else {
            message = ""
            // #3
        }

        if (message.isEmpty) { // Error! Message could be not initialized at this point! 
            println("Empty message")
            // #4
        }
    }
}

Execution paths:

1. #1 -> #2
2. #1 -> #3 -> #4

In this example, Kotlin is sure that the message read-only variable is initialized because there is a 100% chance that one of node 2 or node 3 will be executed. Right after the line where the message gets its initial value (initialized) Kotlin treats this variable as a read-only variable with a value.

Questions are welcome. I will try to simplify this answer.