Как вызвать функцию на внутреннем классе

Question

Следующий код размещен на веб-сайте Kotlin:

class A { // implicit label @A
    inner class B { // implicit label @B
        fun Int.foo() { // implicit label @foo
            val a = this@A // A's this
            val b = this@B // B's this

            val c = this // foo()'s receiver, an Int
            val c1 = this@foo // foo()'s receiver, an Int

            val funLit = lambda@ fun String.() {
                val d = this // funLit's receiver
            }


            val funLit2 = { s: String ->
                // foo()'s receiver, since enclosing lambda expression
                // doesn't have any receiver
                val d1 = this
            }
        }
    }
}

Мне не ясно, как вы вызываете функцию во внутреннем классе.Например, как вы вызываете Int.foo ()

var a = A()
a.Int.foo() // This is not allowed.

Answer 1

Давайте посмотрим на более простой пример:

class A { 

    inner class B { 

        fun foo() { 
          // ...
        }
    }
}

Чтобы вызвать функцию во внутреннем классе, вы должны получить к ней доступ, используя экземпляр внешнего класса, например:

A().B().foo()

Что делает ваш пример более сложным, так это то, что Int.foo() является функцией расширения, поэтому для доступа к ней вы должны вызвать foo() для Int в той же области, что и функция расширения:

class A { // outer class A
    inner class B { // inner class B
        fun Int.foo() { // entension function foo
            print("Foo called on integer $this")
        }

        fun caller(i: Int) { // calls extension function
            i.foo()
        }
    }
}

fun main() {
    A().B().caller(10)   // calls extension function in inner class B
}

Здесь мы добавили функцию caller, которая находится в той же области видимости, что и функция расширения.Код выводит следующее:

Foo called on integer 10

Answer 2

В этом случае foo является функцией расширения, определенной в B.Вы не можете вызывать эти функции расширения члена извне по умолчанию.Однако можно выполнить функцию, когда вы попадете в область действия B, что может быть достигнуто с помощью таких функций определения объема, как with.Помните, что эту функцию расширения можно вызывать только в случаях Int.

val a = A()
val b = a.B()
with(b) {
    5.foo()
}