在Android Java / Kotlin中，实现接口确实可以直接访问嵌套类的局部变量

Question

In Android Java/Kotlin, does implementing an interface give it direct access to the nesting class's local variables. More specifically, when accessing the nesting class's local variables are they passed by value or reference to the interface.

Answer 1

It's unclear to me whether you mean "fields in the outer class" or "locals in the enclosing method", but tl;dr is "everything is by reference". (Well, obviously primitives aren't by reference, but everything else.)

---

A local inner class holds a reference to the outer class. For example,

// Java
public class Outer {
    public class Inner implements Supplier<Outer> {
        @Override public Outer get() {
            return Outer.this;
        }
    }
}
new Outer().new Inner().get();

// Kotlin
class Outer {
    inner class Inner: () -> Outer {
        override fun invoke() = this@Outer
    }
}
Outer().Inner().invoke()

The Outer$Inner class has a compiler-generated final field named this$0 (which the compiler also generates code for filling in at construction time) which is what Outer.this / this@Outer actually refers to.

Accessing fields in the outer class, for example

// Java
public class Outer {
    String string = "";
    public class Inner implements Supplier<String> {
        @Override public String get() {
            return string;
        }
    }
}
new Outer().new Inner().get();

// Kotlin
class Outer {
    var string: String = ""
    inner class Inner: () -> String {
        override fun invoke() = string
    }
}
Outer().Inner().invoke()

is translated to go through the reference to the outer, eg Outer.this.string / this@Outer.string . Ditto with method calls on the outer.

---

An anonymous inner class has the same features as a local inner class for referencing the outer class, plus also having access to local variables in the scope where they were created.

// Java
public class Outer {
    public Supplier<String> inner(final String string) {
        return new Supplier<String>() {
            @Override public Outer get() {
                return string;
            }
        }
    }
}
new Outer().inner("").get();

For references to final local variables, the Java compiler generates a final field to hold them and fills them in during construction of the inner class. References to non- final local variables are not allowed in Java.

Kotlin does that for val (eg final) variables, and additionally allows referencing var (eg non-final) variables.

// Kotlin
class Outer {
    fun inner(string: String): () -> String {
        var string2 = string
        return { string2 }
    }
}
Outer().inner("").invoke()

If a var variable is ever used by an anonymous inner class, the Kotlin compiler converts every access of it to go through a kotlin.jvm.internal.Ref wrapper. A reference to this wrapper can be passed around just like a reference to final variables. If you use the Kotlin plugin in IntelliJ IDEA or Android Studio, the IDE will underline the variable name to indicate that this wrapping is happening automatically.

---

None of the above was Android-specific, it is Java and Kotlin (JVM) behavior. (Kotlin JS and Kotlin native have different implementations but the observable behavior is still the same.)