I have a Kotlin class with a member object:

private var strings = object { var foo = ""; var bar = "" }

Inside my class's functions, I can reference strings.foo and strings.bar.

But when I make strings a public var, suddenly all of its members become "unresolved references". Why?

class Foo {
    // Making this `private` fixes the errors below for some reason
    public var strings = object {
        var foo = ""
        var bar = ""
    }

    fun initialize() {
        strings.foo = getFoo()  // "Unresolved reference: foo"
        strings.bar = getBar()  // "Unresolved reference: bar"
    }
}

(What I'm trying to do here is expose a whole bunch of string resources as constants so I don't have to use the literal string values throughout my code. I'm actually using lateinit var for each member but that doesn't change the result here.)

CodePudding user response：

strings is defined with an object literal. You probably want to use an regular object declaration instead:

object Strings {...}
strings = Strings()

With the object literal, strings is an anonymous object whose type is "usable (and visible) only in the scope where it is declared".

without any explicitly declared supertype, menaing Any is implicit super type of this object.

When you make strings a public var, it escapes the current scope and is implicitly downcasted to its supertype; without any explicitly declared supertype, the supertype is Any, so of course you get errors trying to reference the properties foo and bar.

From Kotlin spec

The main difference between a regular object declaration and an anonymous object is its type. The type of an anonymous object is a special kind of type which is usable (and visible) only in the scope where it is declared. It is similar to a type of a regular object declaration, but, as it cannot be used outside the declaring scope, has some interesting effects.

When a value of an anonymous object type escapes current scope:

1. If the type has only one declared supertype, it is implicitly downcasted to this declared supertype;
2. If the type has several declared supertypes, there must be an implicit or explicit cast to any suitable type visible outside the scope, otherwise it is a compile-time error.

Note: an implicit cast may arise, for example, from the results of type inference.

Note: in this context “escaping current scope” is performed immediately if the corresponding value is declared as a non-private global- or classifier-scope property, as those are parts of an externally accessible interface.

You could also use a Companion object:

companion object Strings {
    var foo = ""
    var bar = ""
}

fun init(){
   foo = getFoo()
   bar = getBar()
}