在Java中调用方法时可以省略'this'吗？

Question

I have silly question about Java (6/7/8) grammar - are those two snippets of method invocation always equivalent?

1. with this

    this.myMethod(4); 

2. without this

    myMethod(4); 

Note: Of course the problem is about every number, type and combination of arguments

Weaker statement: given program P , can I create program P' only by deleting this. in front of each and every method invocation?

I've taken into account local classes, anonymous classes, inner classes and various inheritance but could have not find any contradiction. So i believe both snippets are actually the same. Unfortunately I can't manage to find any suitable proof (eg from the official grammar).

Could you prove me wrong by contradiction or give me some clues for construction of the equivalence proof? Thanks a lot.

EDIT: the equivalence was proven wrong (see comments below) What about the weaker statement ?

Answer 1

The Java Language Specification states

• If the form is MethodName - that is, just an Identifier - then:
  • Otherwise, let T be the enclosing type declaration of which the method is a member, and let n be an integer such that T is the n'th lexically enclosing type declaration of the class whose declaration immediately contains the method invocation. The target reference is the n'th lexically enclosing instance of this .

and

When used as a primary expression, the keyword this denotes a value that is a reference to the object for which the instance method or default method was invoked (§15.12), or to the object being constructed

and

• If the form is Primary . [TypeArguments] Identifier Primary . [TypeArguments] Identifier involved, then:
  • Otherwise, the Primary expression is evaluated and the result is used as the target reference.

Primary here referring to this.* .

In both cases, the method is going to be resolved to the same method. Given all this information, there's is no compilable program P' that can be created from a compilable program P .

Answer 2

There's at least one case where they aren't equivalent. For example, this code

void doStuff(){}
void test(){
    Runnable r = new Runnable(){
        @Override
        public void run(){
            doStuff();
        }
    };
    r.run()
}

Is perfectly valid, while this

void doStuff(){}
void test(){
    Runnable r = new Runnable(){
        @Override
        public void run(){
            this.doStuff();
        }
    };
    r.run()
}

isn't.

So if you have a method defined on a class, an anonymous object declared within that class can call it's methods without using this , but if it uses this it results in a compiler error (assuming it doesn't provide an implementation of the method name itself).