Why Property must be initialized when there is auto back-end field generated

Question

I'm new to properties and moved from the java to kotlin. I'm struggling with the properties, I learned much about it but initializing the properties are confusing me, when it should be initialized or when it can work without initialization.

Let me explain it by the help of code. Below is the code which is requiring to initialize the property when the back-end field generated, before posting the code let me post the paragraph from the kotlin official website.

A backing field will be generated for a property if it uses the default implementation of at least one of the accessors, or if a custom accessor references it through the field identifier.

Now here is the code below.

class Employee{
    var data: String // because there are default implementation of get set
                    // so there will be a back-end field.
}

So I have to initialize it else compilation error.

Ok I can understand it as that some one can access it so there will be no value which can produce the wrong result.

Then I move next to understand it more, so I add custom getter.

class Employee{
    var data: String
    get() = "default value"
}

This also generate the back-end field so compilation error to initialize it. I can understand it as that there is no initialized value so compiler complain about it.

May be compiler is not smart enough yet to check that there is value which is giving result for this property by custom getter so don't complain about initializing just return that value when required.

But there should be not a problem if any one access it then a default value is already there, then why compiler still complain?

Then I move one step more to implement custom setter too.

class Employee{

    var data: String
    get() = "default value"
    set(value){
        field = value
    }

}

Still there is the back-end field because we have accessed the field so compiler generate the back-end field. Same error, should be initialized.

Then the final stage where it works fine as below.

class Employee{

    var data: String
    get() = "default value"
    set(value){

    }

}

Now I'm not accessing field in custom getter setter so there is not a back-end field. And it works fine.

So the final question when the property should be intialized? When there is a back-end field generated?

Answer 1

Yes this does not compile:

class Employee{
    var data: String
    get() = "default value"
}

but this does:

class Employee{
    val data: String
    get() = "default value"
}

so maybe the compiler by stating Property must be initialized for the wrong declaration, wants from you to admit that data is something that you can not change. I say maybe.
Now the part that does compile:

class Employee{

    var data: String
    get() = "default value"
    set(value){

    }
}

This is where you explicitly admit that whatever happens I will never set a value to data, and that's why the compiler feels fine.

Just to save you from more confusion, there's a lot of explaining about Kotlin in the Internet and you may find it very difficult to get familiarized with this relatively new language, but keep in mind that everything needs to be tested by you.
I found the below code in a web page:

class User{
    var firstName : String
        get() = field
        set(value) {field = value}

    var lastName : String
        get() = field
        set(value) {field = value}
}

and it is presented as compilable when it's not.