¿Por qué esta clase interna estática no puede llamar a un método no estático en su clase externa?

Tenga en cuenta el mensaje de error. No está diciendo que no tengas acceso. Está diciendo que el método no se puede llamar. Los métodos de instancia no significan nada sin una instancia para llámalos. Lo que el mensaje de error te está diciendo es que no tienes esa instancia.

Lo que Bloch le está diciendo es que si esa instancia existiera, el código en la clase interna podría llamar métodos de instancia privada en ella.

Digamos que tenemos lo siguiente clase:

public class OuterClass {
  public void publicInstanceMethod() {}
  public static void publicClassMethod() {}
  private void privateInstanceMethod() {}
  private static void privateClassMethod() {}
}

Si tratamos de llamar a esos métodos privados desde alguna clase aleatoria, no podemos:{[16]]}

class SomeOtherClass {
  void doTheThing() {
    OuterClass.publicClassMethod();
    OuterClass.privateClassMethod(); // Error: privateClassMethod() has private access in OuterClass
  }
  void doTheThingWithTheThing(OuterClass oc) {
    oc.publicInstanceMethod();
    oc.privateInstanceMethod();      // Error: privateInstanceMethod() has private access in OuterClass
  }
}

Tenga en cuenta que esos mensajes de error dicen acceso privado.

Si agregamos un método a OuterClass, podemos llamar a esos métodos:

public class OuterClass {
  // ...declarations etc.
  private void doAThing() {
    publicInstanceMethod();  // OK; same as this.publicInstanceMethod();
    privateInstanceMethod(); // OK; same as this.privateInstanceMethod();
    publicClassMethod();
    privateClassMethod();
  }
}

O si añadimos una clase interna estática:

public class OuterClass {
  // ...declarations etc.
  private static class StaticInnerClass {
    private void doTheThingWithTheThing(OuterClass oc) {
      publicClassMethod();  // OK
      privateClassMethod(); // OK, because we're "inside"
      oc.publicInstanceMethod();  // OK, because we have an instance
      oc.privateInstanceMethod(); // OK, because we have an instance
      publicInstanceMethod();  // no instance -> Error: non-static method publicInstanceMethod() cannot be referenced from a static context
      privateInstanceMethod(); // no instance -> Error: java: non-static method privateInstanceMethod() cannot be referenced from a static context
    }
  }
}

Si agregamos una clase interna no estática, parece que podemos hacer magia: {[16]]}

public class OuterClass {
  // ...declarations etc.
  private class NonStaticInnerClass {
    private void doTheThing() {
      publicClassMethod();     // OK
      privateClassMethod();    // OK
      publicInstanceMethod();  // OK
      privateInstanceMethod(); // OK
    }
  }
}

Sin embargo, hay trucos aquí: un no estático interno la clase está siempre asociada con una instancia de la clase externa, y lo que realmente estás viendo es:{[16]]}

  private class NonStaticInnerClass {
    private void doTheThing() {
      publicClassMethod();     // OK
      privateClassMethod();    // OK
      OuterClass.this.publicInstanceMethod();  // still OK
      OuterClass.this.privateInstanceMethod(); // still OK
    }
  }

Aquí, OuterClass.this es una sintaxis especial para acceder a esa instancia externa. Pero solo lo necesita si es ambiguo, por ejemplo, si las clases externa e interna tienen métodos con el mismo nombre.

Tenga en cuenta también que la clase no estática todavía puede hacer las cosas que la estática puede hacer:

  private class NonStaticInnerClass {
    private void doTheThingWithTheThing(OuterClass oc) {
      // 'oc' does *not* have to be the same instance as 'OuterClass.this'
      oc.publicInstanceMethod();
      oc.privateInstanceMethod();
    }
  }

En resumen: public y private son siempre sobre acceso. Punto Bloch está haciendo que las clases internas tengan acceso que otras clases no. Pero ninguna cantidad de acceso le permite llamar a un método de instancia sin decirle al compilador en qué instancia desea llamarlo.

La forma en que lo mostraste requiere herencia. Pero los métodos y campos podrían ser accedidos de esta manera:

public class OuterClass {

  private void printMessage(String message) {
    System.out.println(message);
  }

  private static class InnerClass {

    private void sayHello() {
        OuterClass outer = new OuterClass();
        outer.printMessage("Hello world!"); 
    }

  }
}

Pero, que la clase interna estática no tiene acceso a la función printMessage no tiene que ver con que es una clase interna, sino que es estática y no puede invocar un método no estático. Creo que el uso de la palabra "estática" que usted propuso estaba implícito en la primera frase. Lo que él está señalando, o eligió enfatizar, es solo que la clase interna todavía puede acceder a los métodos privados de su clase padre. Podría haber pensado que era innecesario o confuso hacer que la distinción estática / no estática en la misma oración, también.

Como yo lo veo, el texto es absolutamente correcto. Las clases de miembros estáticos pueden acceder a los miembros privados de las clases que encierran (tipo de). Permítanme mostrarles un ejemplo:

public class OuterClass {
    String _name;
    int _age;
    public OuterClass(String name) {
        _name = name;
    }
    public static OuterClass CreateOuterClass(String name, int age) {
        OuterClass instance = new OuterClass(name);
        instance._age = age; // Notice that the private field "_age" of the enclosing class is visible/accessible inside this static method (as it would also be inside of a static member class).
        return instance;
    }
}