Unterscheiden Sie die integrierten Kotlin-Funktionen
apply、also、run、let、with
1. Unterscheiden Sie aus der Perspektive des Rückgabewerts
- Der Rückgabewert von apply und auch istObjekt
- ausführen und die letzte Codezeile zurückgeben lassenErgebniswert,AngegebenRückgabewert zurückgeben
2. Objektnamen, die in integrierten Funktionen verwendet werden
- Bewerben, ausführen, mit diesem Befehl ausführen
- auch, lasst es nutzen
Wenn Sie thisöffentliche Mitgliedsvariablen verwenden, die in der integrierten Funktion weggelassen werden können und das Objekt direkt aufrufen, itmüssen diese ausgefüllt werden und dürfen nicht weggelassen werden.
Beispiel
Habe zum Testen eine Person-Klasse in Kotlin geschrieben
class Person() {
var name: String? = null
var address: String? = null
var age: Int = -1
private fun initDef() {
name = "Mr.Li";
address = "China"
age = 24
}
init {
initDef()
}
fun setRealName(realName: String) {
this.name = realName
}
fun setPantName(pantName: String) {
this.name = pantName
}
override fun toString(): String {
return "name : $name || address : $address || age : $age "
}
}
fun main(args: Array<String>) {
val man = Person()
println("created -> ${
man.toString()}")
val applyMan = man.apply {
this.age = 18
address = "ShangHai" // this可以省略不写
setPantName("Lmm")
}
println("apply -> ${
applyMan.toString()}")
val alsoMan = man.also {
it.address = "China ShangHai" // it 则不行
it.setRealName("LiMM")
}
println("also -> ${
alsoMan.toString()}")
val runMan = man.run {
age = 30
setPantName("Kuye")
this// this 作为最后的返回值
}
println("run -> ${
runMan.toString()}")
println("runMan Type -> ${
runMan.javaClass.typeName}")
val runManName = man.run {
age = 30
setPantName("Kuye")
name// name 作为最后的返回值
}
println("runManName -> $runManName")
println("runManName Type -> ${
runManName?.javaClass?.typeName}")
val runManReturn: String = man.run {
age = 30
setPantName("Kuye")
name//
return@run "runManReturn" //直接用Return指定一个返回值 这里可以是表达式、成员函数的返回等等
}
println("runManReturn -> $runManReturn")
println("runManReturn Type -> ${
runManReturn.javaClass.typeName}")
val letMan = man.let {
it.address = "China GUANGXI"
it.setRealName("LiMI")
it// it 作为返回值
}
println("letMan -> ${
letMan.toString()}")
println("letMan Type -> ${
letMan.javaClass.typeName}")
val letManReturn: String = man.run {
age = 30
setRealName("Kuye")
name//
return@run "letManReturn" //直接用Return指定一个返回值 这里可以是表达式、成员函数的返回等等
}
println("letManReturn -> $letManReturn")
println("letManReturn Type -> ${
letManReturn.javaClass.typeName}")
with(man) {
// this可以省略不写
setPantName("LMM")
this.address = "China SHANGHAI"
age = 15
}
println("with man -> $man")
}
Ausgabeergebnis:
created -> name : Mr.Li || address : China || age : 24
apply -> name : Lmm || address : ShangHai || age : 18
also -> name : LiMM || address : China ShangHai || age : 18
run -> name : Kuye || address : China ShangHai || age : 30
runMan Type -> infunc.Person
runManName -> Kuye
runManName Type -> java.lang.String
runManReturn -> runManReturn
runManReturn Type -> java.lang.String
letMan -> name : LiMI || address : China GUANGXI || age : 30
letMan Type -> infunc.Person
letManReturn -> letManReturn
letManReturn Type -> java.lang.String
with man -> name : LMM || address : China SHANGHAI || age : 15