Android “什么是”呢；。()"；在科特林是什么意思？

我见过一些例子，其中一个函数有一个由类名给出的参数。（） 这似乎不是一个扩展函数，它是ClassName.function（）

例如：

我不太清楚它的功能

及

代码允许您直接调用

drawer {
    ...
}

而不是用括号括起来的参数

---

任何地方都有关于此的文档吗？

在Kotlin中不接收任何内容也不返回任何内容的函数如下所示：

var function : () -> Unit

不同之处在于，代码中的函数不返回任何内容，不接收任何内容，而是在对象上调用

比如说,

class Builder (val multiplier: Int) {

    fun invokeStuff(action: (Builder.() -> Unit)) {
        this.action()
    }

    fun multiply(value: Int) : Int {
        return value * multiplier
    }
}

这里重要的一点是我们声明“动作”类型的方式

action: (Builder.() -> Unit)

这是一个不返回任何内容、不接受任何内容的函数，但在类型为“Builder”的对象上被调用

---

关于@Kris Roote的回答让事情变得清楚了。让我再补充一点

有趣的活动。drawer表示我们正在

Activity

类中创建扩展函数名

drawer

。这就是我们可以打电话的原因 直接来自活动类或活动子级的抽屉方法 班级

更多关于扩展函数的信息

（setup:DrawerBuilderKt.（->Unit={}）在这个语句中，我们可以看到kotlin高阶函数的强大功能。高等教育小介绍 顺序函数：-

它是一个将函数作为参数或返回函数的函数。

因此这里的setupparam是一个 不返回任何内容或单元的函数（与java中的Void相同）。 DrawerBuilderKt。（表示可以使用

DrawerBuilderKt

类的对象调用函数={}表示设置参数为 可选。因此，该函数不接受任何参数，也不返回任何内容

更多关于高阶函数和。更多关于可选参数的信息

private val View.viewFinder:View.（Int）->View？它在属性中存储函数。更多关于同样的信息。其余的事情和上面解释的一样

---

希望这会有所帮助。

这是个好问题。所以当你有这样的陈述：

T.（）

这意味着在lamda中，您将传入“this”（即当前对象）类型为T。让我们看看它有多容易理解：

假设我们有一个类，它有一个名为myFun的函数，它接受一个定义如下的lambda：

 class MyObject {
        fun myFun(doSomething: MyObject.()->Unit) {
            doSomething()
        }

        fun doAnotherThing() {
            Timber.d("myapp", "doing another thing")
        }
    }

要调用此函数，我将执行以下操作：

MyObject().myFun { doAnotherThing() }

看看它是如何知道使用MyObject（）引用作为“this”的。这实际上是调用this.doAnotherThing（），这里是刚刚创建的Myobject（）实例

也可以这样做：

MyObject().apply{myFun { doAnotherThing() }}  

---

有一种误解认为T.（）->Y是（T.（））->Y，但实际上是T.（（）->Y）。 我们知道（X）->Y是lambda，所以T（X）->Y是T上的一个扩展

如果没有参数，则表单为 T.（）->Y

有趣的是，我们可以用两种方式来称呼它

import kotlinx.coroutines.*


open class MyClass(var name: String){
    open fun something(){println("myclass something")}
}


fun main() = runBlocking{
    val me = MyClass("Boll")
    val someMethod: MyClass.(Int) -> String = { n ->
        List(n){"X"}.joinToString(separator="", postfix=":${this.name}")
    }
    val some = me.someMethod(10)
    //val some = someMethod(me, 10)
    println(some)

    val anotherMehtod: MyClass.() -> String = { 
        "Y:"+this.name
    }
    //val another = me.anotherMehtod()
    val another = anotherMehtod(me) 
    println(another)
}

---

您应该看看带有接收器的lambda：如果函数的最后一个参数是lambda，那么您可以将它从括号中拉出来，放入由{}包围的块中，就像在

抽屉中的
示例中一样，这是一个非常有趣的发现。我很好奇anotherMehtod（我）是如何工作的。嗨，为什么你总是用doAnotherThing（）来称呼它？Doanothing（）在这里有什么关系？我不明白，我只是在证明引用不需要使用它。doAnotherThing（）就是doAnotherThing（）
MyObject().apply{myFun { doAnotherThing() }}  

import kotlinx.coroutines.*


open class MyClass(var name: String){
    open fun something(){println("myclass something")}
}


fun main() = runBlocking{
    val me = MyClass("Boll")
    val someMethod: MyClass.(Int) -> String = { n ->
        List(n){"X"}.joinToString(separator="", postfix=":${this.name}")
    }
    val some = me.someMethod(10)
    //val some = someMethod(me, 10)
    println(some)

    val anotherMehtod: MyClass.() -> String = { 
        "Y:"+this.name
    }
    //val another = me.anotherMehtod()
    val another = anotherMehtod(me) 
    println(another)
}