Question

I have the following case of inner classes.

class Outer {
   private class Inner1 extends InnerBase {
   }
   private class Inner2 extends InnerBase {
   }
   private class InnerBase {
   }
}

Usually I considered an inner class to have an additional, hidden “this” to the outer class.

However, but what will happen is the inner class is derived from an other inner class?

All inner classes (Inner1, Inner2, InnerBase) should have an additional this.

Will Inner1, Inner2 have own references to outer this ?
Or just reusing the one from InnerBase, causing a slightly different behavior?

(Hidden this == a reference pointing to the instance of outer class)

Answer 1

Internally each non-static inner class in the hierarchy will have its own reference to this. You can confirm it with javap

$ javap -private Outer.Inner1
Compiled from "Outer.java"
class Outer$Inner1 extends Outer$InnerBase{
    final Outer this$0;
    private Outer$Inner1(Outer);
}

$ javap -private Outer.InnerBase
Compiled from "Outer.java"
class Outer$InnerBase extends java.lang.Object{
    final Outer this$0;
    private Outer$InnerBase(Outer);
    Outer$InnerBase(Outer, Outer$1);
}

BTW, if you really want, you can exploit some obscure java syntax to have different values for the this$0 member between the parent and child class. Here’s how:

public class Outer {
    class InnerBase {
        Outer innerBaseOuter() { return Outer.this; }
    }

    class Inner1 extends InnerBase {
        public Inner1() {}
        public Inner1(Outer parentOuter) {
            parentOuter.super(); // set a different super in InnerBase
        }
        Outer innerOuter() { return Outer.this; }
    }

    public static void main(String[] args) {
        Outer outer1 = new Outer();
        Outer outer2 = new Outer();

        Inner1 a = outer1.new Inner1();
        System.out.println("Checking (a.base == a.inner) => "+
            (a.innerBaseOuter() == a.innerOuter()));

        Inner1 b = outer1.new Inner1(outer2);
        System.out.println("Checking (b.base == b.inner) => "+
            (b.innerBaseOuter() == b.innerOuter()));
    }
}

Running the program you get:

Checking (a.base == a.inner) => true
Checking (b.base == b.inner) => false