隐式引用Java中的封闭类

Question

Lets say I have a Outer class. Lets say there is a non static member class Inner . So an Outer instance will have a reference to an instance of Inner if the Outer class declares a field of type Inner and that is by definition. But how does Inner instance also has a implicit reference to Outer ? When is this association created?

Answer 1

From the Java language Spec

An instance i of a direct inner class C of a class O is associated with an instance of O, known as the immediately enclosing instance of i. The immediately enclosing instance of an object, if any, is determined when the object is created (§15.9.2).

Answer 2

You have it the other way around:

public class Outer {

    void foo() {
        // In this Outer method, we have no implicit instance of Inner.
        innerbar(); // Compiler error: The method bar() is undefined for the type Outer
        Inner.this.innerbar();// Compiler error: No enclosing instance of the type Outer.Inner is accessible in scope

        // instead, one has to create explicitly instance of Inner:

        Inner inner1 = new Inner();
        Inner inner2 = new Inner();

        inner1.innerbar(); // fine!
    }


    class Inner {
        void innerbar() {};

        void callOuter () {
            // But Inner has an implicit reference to Outer.
            callMe();
            // it works also through Outer.this
            Outer.this.callMe();
        }
    }

    void callMe() {}

}

Answer 3

The code

class Outer {

    class Inner {
        void printOuterThis() {
            System.out.println(Outer.this);
        }
    }

}

Outer.Inner oi = new Outer().new Inner();

is mostly equivalent to this:

class Outer {

    static class Inner {
        Outer outerThis;

        public Inner(Outer outerThis) {
            this.outerThis = outerThis;
        }

        void printOuterThis() {
            System.out.println(outerThis);
        }
    }
}

public class Scratch {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer.Inner(new Outer());
    }
}

The compiler automatically emits code that does what happens in the second: a field ( this$0 that holds the value of Outer.this ) for the implicit reference and transforms all constructors of Inner and calls to them to add initialisation of this field.