kotlin - 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除了能见度一样吗？这是一种将方法封装在伴生对象中的方法吗？

更新 1

在我的实际项目中，我调用的是 inline另一个函数 inline伴随对象中的函数，这就是不能使用访问修饰符的原因。但是我还是想隐藏 foo如果可能的话。

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

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

Answer 1

在您的示例中，定义 Companion.foo()是 extension as a member .在这种情况下，您以相同的类型定义扩展名 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()是伴生对象上的一个方法，但带有第二个 this 的额外参数引用。

要将方法封装在同伴中，只需将 private函数前的修饰符。

如果需要内联函数，请使用 internal和 @PublishedApi 从公共(public) API 隐藏函数。

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

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