What is the difference of the anonymous internal class directly call the external class instance method in the OpenJDK and Oracle?

Question

Today, I reviewed same Android code, and found a strange phenomenon.

It is the anonymous internal class directly called the external class instance method.

In my mind, directly calling a method is equivalent to adding this directly before the method, and this is an instance of an inner class.

According to this logic, an instance of an external class is invoked directly in the anonymous inner class, that will caused the compile ERROR.

But actually compile this application, and no problem. And the running log is normal.

Therefore, writing a simple Demo to verify the previous concept is wrong. code show as below:

public class InnerClass {
    public static void main(String[] args) {
        new InnerClass().process();
    }

    public void process() {
        new Thread() {
            @Override
            public void run() {
                System.out.println(toString("test"));
            }
        }.start();
    }

    public String toString(String string) {
        return string;
    }
}

In the Oracle:

In the OpenJDK:

So, What is the difference of the anonymous internal class directly call the external class instance method in the OpenJDK and Oracle?

Where can I find documentation to see these differences?

I worked hard, but did not get a clear answer.

Thanks.

P.S.

In According to my point of view

public class InnerClass {
    public static void main(String[] args) {
        new InnerClass().process();
    }

    public void process() {
        new Thread() {
            @Override
            public void run() {
                // In According to my point of view
                // toString("test")
                // <==>
                // this.toString("test")
                // and `this` is the instance of Thread
                // what's the error of my view?
                System.out.println(toString("test"));
            }
        }.start();
    }

    public String toString(String string) {
        return string;
    }
}

Answer 1

The problem is that

        public void run() {
            System.out.println(toString("test"));
        }

is calling toString on the anonymous Thread subclass, and that is Thread::toString(). There is no Thread::toString(String), and the toString(String) method from the enclosing scope is not considered.

The JLS states that it will only check an enclosing / outer class for a method if there is no method with the required name in the inner class. See JLS 15.12.1:

If the form is MethodName, that is, just an Identifier, then:

• If the Identifier appears in the scope of a visible method declaration with that name (§6.3, §6.4.1), then:

  • If there is an enclosing type declaration of which that method is a member, let T be the innermost such type declaration. The class or interface to search is T.

    This search policy is called the "comb rule". It effectively looks for methods in a nested class's superclass hierarchy before looking for methods in an enclosing class and its superclass hierarchy. See §6.5.7.1 for an example.

As to why OpenJDK Java 7 accepts your test class .... if that is actually true, I'd call that a compiler bug. But it would be a general Java 7 bug not an OpenJDK specific one. The javac codebases are (AFAIK) identical for Oracle and OpenJDK releases of the same version.

Interestingly, I have a copy of Oracle Java 6, and javac from that version also calls this a compilation error as well.

$ /usr/java/jdk1.6.0_45/bin/javac InnerClass.java 
InnerClass.java:10: cannot find symbol
symbol: method toString(java.lang.String)
                System.out.println(toString("test"));
                                   ^
1 error

So ... maybe ... you should rerun your OpenJDK Java 7 test, and make sure you are compiling the same source code!