2

I'm using something similar to the following code in one of my Java classes:

public class SomeClass {
    private int someValue;

    void incrementValue() {
        someValue++;
    }

    public abstract static class InnerClass {
        private final SomeClass toRunOn;

        public InnerClass(SomeClass obj) {
            toRunOn = obj;
        }

        public abstract void execute();

        // To allow us to call this on a given instance
        final SomeClass getObj() {
            return toRunOn;
        }
    }

    public final InnerClass called = new InnerClass(this) {
        public final void execute() {
            incrementValue(); // This is what I thought should be throwing an error
        }
    };
}

However, while I would expect this to throw a compiler error in the called field defining execute() due to me not giving incrementValue() an object to work on (which is why I allowed for passing this to the inner class), it is completely fine with it. I'm uncertain why this is not giving me an error, and further confused as to what instance it would be calling on.

Am I misunderstanding some form of reference calling here, or is something more subtle going on?

SOFe
  • 7,867
  • 4
  • 33
  • 61
Addison Crump
  • 666
  • 5
  • 19
  • An (non-static) inner class always has an implicit reference to the outter `this`. You're calling `SomeClass.this.incrementValue()` here. Cf http://stackoverflow.com/questions/2731719/how-can-this-of-the-outer-class-be-accessed-from-an-inner-class – zapl Mar 13 '16 at 12:45
  • @zapl O.o Well that makes this a little more convenient. – Addison Crump Mar 13 '16 at 12:47

1 Answers1

2

called is assigned an instance of an anonymous sub-class of InnerClass. Since it's an instance member, it is initialized when an instance of SomeClass is created.

Since it is declared in the body of SomeClass, it is an inner class of SomeClass and has access to the instance methods and members of SomeClass. incrementValue() will be executed on the instance of SomeClass for which the called member was initialized.

Perhaps it would be easier to understand if you replace the anonymous class with an equivalent regular inner class :

public class SomeClass {

    ....

    class SubInnerClass extends InnerClass {
        public final void execute() {
            incrementValue();
        }
    }

    public final InnerClass called = new SubInnerClass(this);

    ....
}
Eran
  • 387,369
  • 54
  • 702
  • 768