私有接口方法的方法引用

Question

考虑以下代码：

public class A {
    public static void main(String[] args) {
        Runnable test1 = ((I)(new I() {}))::test;  // compiles OK
        Runnable test2 = ((new I() {}))::test;     // won't compile 
    }

    interface I {
        private void test() {}
    }
}

我不太明白...我知道test() 方法是private。但是，如果我们将匿名类强制转换为它的接口((I)(new I() {}))，会发生什么变化？更准确地说，我希望看到一个允许该技巧的特定 JLS 点。

P.S. 我已将其报告为编译器的错误（ID：9052217）。在我看来，Runnable test2 = ((new I() {}))::test; 在这种特殊情况下应该编译得很好。

P.P.S. 到目前为止，根据我的报告创建了一个错误：https://bugs.openjdk.java.net/browse/JDK-8194998。可能会以“无法修复”或其他方式关闭。

Answer 1

这不是一个新问题，与私有接口方法或方法引用无关。

如果您更改代码以扩展类而不是实现接口，并调用方法而不是引用它，您仍然会遇到完全相同的问题。

class A {
    public static void main(String[] args) {
        ((I)(new I() {})).test();  // compiles OK
        ((new I() {})).test();     // won't compile 
    }

    class I {
        private void test() {}
    }
}

但是，该代码可以应用于较旧的 Java 版本，我尝试了 Java 9、8、7、6、5 和 1.4。都一样！！

问题是私有方法没有被继承¹，所以匿名类根本没有这个方法。由于匿名类中甚至不存在私有方法，因此无法调用。

当您转换为 I 时，该方法现在存在供编译器查看，并且由于 I 是一个内部类，因此您被授予访问权限（通过合成方法），即使它是私有的。

在我看来，这不是一个错误。这就是私有方法在继承上下文中的工作方式。

^{1) 作为JLS 6.6-5 中的found by Jorn Vernee：“[A private class member] 不被子类继承”。}

Answer 2

private 方法没有被继承（到目前为止我发现的最接近的是：JLS6.6-5：“[A private class member] 没有被子类继承”）。这意味着您不能从子类型访问私有方法（因为它根本没有“拥有”该方法）。例如：

public static void main(String[] args) {
    I1 i1 = null;
    I2 i2 = null;

    i1.test(); // works
    i2.test(); // method test is undefined
}

interface I1 {
    private void test() {}
}

interface I2 extends I1 {}

这也意味着你不能通过匿名子类的类型直接访问test方法。 表达式的类型：

(new I() {})

不是I，实际上是匿名子类的不可表示类型，所以无法通过它访问test。

但是，表达式的类型：

((I) (new I() {}))

是I（当您明确地将其转换为I），因此您可以通过它访问test 方法。 （就像你可以在我上面的例子中做((I1) i2).test();）

类似的规则适用于static 方法，因为它们也不是继承的。

Answer 3

无论场景如何，都只能通过完全声明类型的表达式调用private 方法。

我们用最简单的例子来解释一下

public class A {
    public static void main(String[] args) {
        B b = new B();
        b.someMethod(); // does not compile
        A a = b;
        a.someMethod(); // no problem
    }
    private void someMethod() {}
}
class B extends A {
}

您可能希望它使用b.someMethod() 来编译以调用A 的someMethod()。但是如果B 被声明为

class B extends A {
    public void someMethod() {}
}

这是可能的，因为private void someMethod() 没有被继承，所以public void someMethod() 不会覆盖它。但应该清楚的是，现在b.someMethod() 应该调用B 的方法。

因此，如果允许b.someMethod() 以A 的private 方法结束，这将取决于B 是否声明另一个someMethod()，调用将以哪个实际方法结束。这显然与private 方法的整个概念相矛盾。 private 方法不会被继承，也不会被覆盖，因此它不应该依赖于子类，无论调用是否以 private 方法或子类的方法结束。

您的示例类似。实现I 的匿名内部类可以声明自己的test() 方法，例如Runnable test2 = ((new I() {void test() {}}))::test; 所以它取决于那个匿名内部类，无论是调用I 的private 方法还是那个匿名内部类的方法，这是不可接受的。当然，对于这样的内部类，直接在调用或方法引用之前，读者可以立即知道调用将在哪个方法处结束，但是如果允许匿名内部类但什么都没有，这将是非常不一致的否则。

I 的 private 方法可以被 A 访问，因为它是一个嵌套接口，但如上面更简单的示例所示，该规则与可访问性无关，因为该规则甚至适用于 @ 987654348@方法与调用者在同一个类中。

Answer 4

这是违反直觉的。首先让我们简化一下：

static interface Inter {
    private void test() {
        System.out.println("test");
    }
}


public static void main(String[] args) {
    ((Inter) new Inter() {
    }).hashCode();
}

这是有道理的，因为您正在调用公共 hashCode 方法，这里是它的（仅重要部分）字节码：

public static void main(java.lang.String[]);
Code:
   0: new           #2   // class com/test/DeleteMe$1
   3: dup
   4: invokespecial #3   // Method com/test/DeleteMe$1."<init>":()V
   7: invokevirtual #4   // Method java/lang/Object.hashCode:()I
  10: pop
  11: return

对我来说看起来很理智。现在让我们将其更改为调用test()：

public static void main(String[] args) {
    ((Inter) new Inter() {
    }).test();
}

这个的字节码：

 invokestatic  #4  // InterfaceMethod com/test/DeleteMe$Inter.access$000:(Lcom/test/DeleteMe$Inter;)V

由于私有方法没有被继承，你实际上是通过access$n静态合成方法“去”那个方法。