CODEWITHSUNDEEP
kotlin
Jakub
Jakub

Reputation: 822

Scope of methods of an anonymous object - Kotlin

In Kotlin if I define a method on an anonymous object, sometimes I am able to access it, while other times I am not. This seems to have something to do with scoping rules, but I am not sure what.

In the code example below, the access to example3.field.method() will cause a compilation error. Interestingly, example2.field.method() compiles just fine.

What could be the explanation for the below behaviour?

class Example3 {
    val field = object {
        fun method() {}
    }
}

fun showcase() {
    val example1 = object {
        fun method() {}
    }
    example1.method()
    println(example1::class.qualifiedName)

    class Example2 {
        val field = object {
            fun method() {}
        }
    }

    val example2 = Example2()
    example2.field.method()
    println(example2::class.qualifiedName)

    val example3 = Example3()
    // example3.field.method()  // won't compile
    println(example3::class.qualifiedName)
}

Upvotes: 1

Views: 564

Answers (2)

Gustavo Pagani
Gustavo Pagani

Reputation: 6988

Pawel gave the correct answer to your question, pointing to the documentation:

the actual type of that function or property will be the declared supertype of the anonymous object, or Any if you didn't declare any supertype.

But just adding that if you really need to access example3.field.method() you could declare a supertype to field in Example3: 

interface MyInterface {
    fun method()
}

class Example3 {
    val field = object: MyInterface { 
        override fun method() {} 
    }
}

fun main() {
    val example3 = Example3()
    example3.field.method()
}

Upvotes: 2

Pawel
Pawel

Reputation: 17258

From docs Object Expressions and Declarations:

Note that anonymous objects can be used as types only in local and private declarations. If you use an anonymous object as a return type of a public function or the type of a public property, the actual type of that function or property will be the declared supertype of the anonymous object, or Any if you didn't declare any supertype. Members added in the anonymous object will not be accessible.

Demonstrated in code sample below:

class Example4{
    val publicObj = object{
        val x = 1
    }

    private val privateObj = object{
        val x = 2
    }

    fun showcase(){
        val scopedObj = object{
            val x = 3
        }
        println(publicObj.x)    // ERROR : unresolved reference: x
        println(privateObj.x)   // OK
        println(scopedObj.x)    // OK
    }
}

Upvotes: 6

Related Questions