How to access super of enclosing class from inner class?

Question

Hello,
I'd like to access Base.foo() from inner class in overridden Improved.foo(), but seem unable:
public class InnerSuper {
     public static class Base {
          protected int foo() {
               return 1;
     public static class Improved extends Base {
          @Override
          protected int foo() {
               return Integer.parseInt(new Object () {
                    public String toString() {
                         return "1"+foo() ;
               }.toString());
     public static void main(String[] args) {
          System.out.println(new Improved().foo());
}The code above does not work, as it recursively calls Improved.foo() where I'd like it to call Base.foo(). What syntax construct should I use? Improved.this would be the same thing, Improved.super does not exist.
I came up with a work around: adding a method baseFoo() to Improved and call that in the inner class:
   int baseFoo() {
      return super.foo();
   } but remain wondering if that is necessary?

Answer 1

Indeed, Improved.super.foo() is allowed. My Eclipse syntax highlighting seems to have the same opinion as you: "are you sure you want to write that kind of code?" and leaves the read underlining for a syntax error on for just a second longer.
This is where I am now:
     public static class DeferredExecSubroutineCall extends SubroutineCall {
          RelayExecutor relay;
          public DeferredExecSubroutineCall(RelayExecutor relay) {
               this.relay = relay;
          @Override
          protected String execute(final IFDSOC fd, final String commandText) {
               Future<String> f = relay.submit(new Callable<String>() {
                    @Override
                    public String call() throws Exception {
                         return DeferredExecSubroutineCall.super.execute(fd, commandText);
               try {
                    return f.get();
               } catch (InterruptedException e) {
                    throw new RuntimeException(e);
               } catch (ExecutionException e) {
                    if (e.getCause() instanceof RuntimeException) {
                         throw (RuntimeException) e.getCause();
                    } else {
                         throw new RuntimeException(e.getCause());
     }which is my current effort of adding concurrency to an existing project. I find it quite elegant but I am interested to hear from you...