为什么我不能调用同名匿名类之外的方法

Question

最后的代码会产生编译错误：

NotApplicable.java:7: run() in  cannot be applied to (int)
                run(42);
                ^
1 error

问题是为什么？ 为什么 javac 认为我正在调用 run()，但没有找到 run(int bar)？ 它正确地调用了 foo(int bar)。 为什么我必须使用 NotApplicable.this.run(42);？ 这是一个错误吗？

public class NotApplicable {

    public NotApplicable() {
        new Runnable() {
            public void run() {
                foo(42);
                run(42);
                // uncomment below to fix
                //NotApplicable.this.run(42);
            }
        };
    }

    private void run(int bar) {
    }

    public void foo(int bar) {
    }
}

Answer 1

对代码示例行为的解释是 this 被定义为您当前“最”位于其中的类。 在这种情况下，您位于可运行子类的匿名内部类中的“最”部分，并且没有与 run(int) 匹配的方法。 要扩大搜索范围，您可以通过声明 NotApplicable.this.run(42) 来指定要使用的 this。

jvm 将进行如下评估：

this -> 当前使用方法 run() 执行 Runnable 实例

NotApplicable.this -> 当前使用方法 run(int) 执行 NotApplicable 的实例

编译器将在嵌套树中查找第一个与该方法的 NAME 匹配的方法。 -感谢 DJClayworth 的澄清

匿名内部类不是外部类的子类。 由于这种关系，内部类和外部类都应该能够拥有具有完全相同签名的方法，并且最里面的代码块应该能够识别它想要运行哪个方法。

public class Outer{

    public Outer() {
        new Runnable() {
            public void printit() {
                System.out.println( "Anonymous Inner" );
            }
            public void run() {
                printit(); // prints "Anonymous Inner"
                this.printit(); //prints "Anonymous Inner"

                // would not be possible to execute next line without this behavior
                Outer.this.printit(); //prints "Outer" 
            }
        };
    }

    public void printit() {
        System.out.println( "Outer" );
    }
}

Answer 2

据我记得，选择在嵌套类之间运行的方法的规则与选择继承树中的方法的规则大致相同。 这意味着我们在这里得到的不是超载，而是隐藏。 它们之间的区别对于理解继承中的方法至关重要。

如果您的 Runnable 被声明为子类，那么 run() 方法将隐藏父类中的 run(int) 方法。 对 run(...) 的任何调用都会尝试执行 Runnable 上的调用，但如果无法匹配签名，则会失败。 由于 foo 未在子级中声明，因此将调用父级中的 foo 。

同样的原理也发生在这里。 查找“方法隐藏”的参考文献，它应该很清楚。

Answer 3

这是因为当您进入 new Runnable() {} 作用域时，run 被重新声明。 所有之前要运行的绑定都变得无法访问。 就好像您正在这样做：

import java.util.*;

public class tmp
{
  private int x = 20;
  public static class Inner
  {
      private List x = new ArrayList();
      public void func()
      {
          System.out.println(x + 10);
      }
  }

  public static void main(String[] args)
  {
    (new Inner()).func();
  }
}

编译器不会在作用域堆栈中一直寻找与 x 类型匹配的内容，它只会在找到第一个引用并看到时停止类型不兼容。

注意：这并不是说它不能这样做......只是为了保持你自己的理智，我们决定不应该这样做。