在同伴对象中有companion.foo有什么区别？

Question

在Kotlin中，如果我在同伴对象中有一个以companion.作为前缀(companion.foo)的函数，那么与同伴对象中的foo相比会有什么不同呢？

我注意到，在下面的代码中，companion.foo将使它对外部作用域不可见，但对同一同伴对象内部的函数仍然可见。

您可以在:https://pl.kotl.in/T6FVM6NI6找到代码片段

fun main() {
    A.foo() // compiler complains "unresolved reference"
    A.bar()
    B.foo()
}

class A {
    companion object {
        fun Companion.foo() {
            println("hello in A")
        }

        fun bar() {
            foo()
        }
    }
}

class B {
    companion object {
        fun foo() {
            println("hello in B")
        }
    }
}

还有其他区别吗？a.companion.foo和a.foo除了可见性之外是否相同？这是将方法封装在陪伴对象中的一种方法吗？

class C {
    companion object {
        inline fun <reified T> Companion.foo() {
            println("hello in A")
        }

        inline fun bar() {
            foo<String>()
        }
    }
}

Answer 1

在您的示例中，定义companion.foo()是作为成员的扩展。在本例中，您在与扩展的类型相同的类型a.companion中定义扩展。这是没用的。

下一个示例显示了扩展作为具有两个不同类的成员的概念。这个例子没有同伴，因为它对概念没有区别。

class A 

class B {
    fun A.foo() {
        println("Extension for A, only visible in B")
        println("Function has two 'this' references: ${this} and ${this@B}")
    }

    fun bar() {
        val a = A()
        a.foo() // this function call is only possible in the context of `B`
    }
}

fun main() {
    val a = A()
    a.foo() // compile error
}

尽管如此，示例中的两个foo()函数在内部具有不同的签名。普通函数foo()是在没有参数的陪伴对象上的一个简单方法。扩展函数companion.foo()是companion对象上的一个方法，但为第二个this引用添加了一个额外的参数。

class C {
    companion object {
        @PublishedApi
        internal inline fun <reified T> foo() {
            println("hello in A")
        }

        inline fun bar() {
            foo<String>()
        }
    }
}