Kotlin delegate property knowledge points

Kotlin delegate property keyword By lazy

By is the keyword of the delegate property, the code is as follows:
class user {
var name :String by Delegate()
}
This is to delegate name to Delegate(), now create a Delegate class
class Delegate{
Two methods will be created in it
setValue () {

}
and getValue(){

} method The compiler will let you automatically generate
}

How to use it

fun main() { val user = User()
user.name = "Zhang San"
println(user.name)
}

The print result is as follows: Zhang San

by lazy lazy loading attribute

The type of lazy-loaded properties is similar to that of lazy-initialized properties. The initialization operation can only be performed when the property is accessed for the first time. The lazy-loaded property application uses the lazy function to apply for the delegated property, and the delayed-initialized property uses the lateinit keyword.There is a certain difference between the two
lazy loading properties must be val properties
lateinit properties must be var properties
use the code as follows
val user : String by lazy {
println(this method is executed only once)
Hello
}
fun main(){
println (user)
println (user)
}
The print result is as follows
This method is executed only once
The above assignment is executed only once
The above assignment is executed only once

Seeing the above results, the conclusion is that the first line of code above is only executed once. Note that the method followed by the curly braces can be a lambda expression
Now

Observable Properties

var name:String by XXX.observable("None") { porp,oldValue,newValue ->
println("$oldValue 0> $newValue")
}
fun main(){

name = "Zhang San"
name = "Zhang Si"
}

The print result is as follows:
None -> Zhang San
Zhang San -> Zhang Si
Conclusion: It can be clearly seen from the print result, in fact, this method can observe the attribute to change process, just like from android to JetPack to ViewModel, it can be very simple to implement UI interface to update
Another method is that vetoable can intercept an assignment process and reject it.

Store attributes in a map

It is often used to store the value of the attribute in the mapping map.This is often used in json or other dynamic applications, in which case the map instance itself can be used as a delegate to implement the delegate property
class User(val map: Map) {
val name : String by map
val age : Int by map If age is cancelled, an error will occur
}
Usage:
val user =User(mapOf(“name” to “Zhang San”, “age” to 20))