为什么 'T.super.toString()' 和 'super::toString' 使用合成访问器方法？

Question

考虑以下一组表达式：

class T {{
/*1*/   super.toString();      // direct
/*2*/   T.super.toString();    // synthetic
        Supplier<?> s;
/*3*/   s = super::toString;   // synthetic
/*4*/   s = T.super::toString; // synthetic
}}

结果如下：

class T {
    T();
     0  aload_0 [this]
     1  invokespecial java.lang.Object() [8]
     4  aload_0 [this]
     5  invokespecial java.lang.Object.toString() : java.lang.String [10]
     8  pop           // ^-- direct
     9  aload_0 [this]
    10  invokestatic T.access$0(T) : java.lang.String [14]
    13  pop           // ^-- synthetic
    14  aload_0 [this]
    15  invokedynamic 0 get(T) : java.util.function.Supplier [21]
    20  astore_1 [s]  // ^-- methodref to synthetic
    21  aload_0 [this]
    22  invokedynamic 1 get(T) : java.util.function.Supplier [22]
    27  astore_1      // ^-- methodref to synthetic
    28  return

    static synthetic java.lang.String access$0(T arg0);
    0  aload_0 [arg0]
    1  invokespecial java.lang.Object.toString() : java.lang.String [10]
    4  areturn

    Bootstrap methods:
    0 : # 40 invokestatic java/lang/invoke/LambdaMetafactory.metafactory:...
        #43 invokestatic T.access$0:(LT;)Ljava/lang/String;
    1 : # 40 invokestatic java/lang/invoke/LambdaMetafactory.metafactory:...
        #46 invokestatic T.access$0:(LT;)Ljava/lang/String;
}

为什么 java 代码行/*2*/、/*3*/ 和/*4*/ 生成并使用合成访问器方法 access$0？我希望/*2*/ 行和/*3*/ 行和/*4*/ 行的引导方法也像/*1*/ 行一样使用invokespecial。

特别是当方法Object::toString 可以直接从相关范围访问时，例如以下方法引用不包含对合成访问器方法的调用：

class F {{
    Function<Object, ?> f = Object::toString; // direct
}}

但是，有不同：

class O {{
        super.toString();      // invokespecial -> "className@hashCode"
        O.super.toString();    // invokespecial -> "className@hashCode"
        Supplier<?> s;
        s = super::toString;   // invokespecial -> "className@hashCode"
        s = O.super::toString; // invokespecial -> "className@hashCode"
        Function<Object, ?> f = Object::toString;
        f.apply(O.super); // invokeinterface -> "override"
    }
    public String toString() {return "override";}
}

这带来了另一个问题：有没有办法绕过((Function<Object, ?> Object::toString)::apply 中的覆盖？

Answer 1

Holger 已经解释了 为什么 它会发生 - super 引用仅限于直接子类。这只是那里实际发生的事情的更详细的版本：

---

调用封闭类型的超类方法

class T {
    class U {
        class V {{
/*2*/       T.super.toString();
        }}
    }
}

它生成一系列合成访问器方法：

class T {
    static synthetic String access$0(T t) { // executing accessor
        return t.super.toString(); // only for the refered outer class
    }
    class U { // new U(T.this)
        static synthetic T access$0(U u) { // relaying accessor
            return T.this; // for every intermediate outer class
        }
        class V {{ // new V(U.this)
            T.access$0(U.access$0(U.this)); // T.access$0(T.this)
        }}
    }
}

当T 是直接封闭类时，即没有中间外部类，只有“执行”访问器在类T 中生成（即其本身，这似乎是不必要的）。

注意：访问器链是由 Eclipse 生成的，而不是由 OpenJDK 生成的，见下文。

---

方法引用自己的超类的方法

class T {
    class U {
        class V {{
            Supplier<?> s;
/*3*/       s = super::toString;
        }}
    }
}

这会生成一个合成访问器方法和一个委托给它的引导方法：

class T {
    class U {
        class V {
            static synthetic String access$0(V v) {
                return v.super.toString();
            }
            dynamic bootstrap Supplier get(V v) { // methodref
                return () -> V.access$0(v); // toString() adapted to get()
            }
            {
                get(V.this);
            }
        }
    }
}

这是一个与上一个类似的单数情况，因为super::toString在这里等同于V.super::toString，所以合成访问器是在类V本身中生成的。这里的一个新元素是用于将Object::toString 适配为Supplier::get 的引导方法。

注意：这里只有 OracleJDK 足够“智能”（正如Holger 指出的那样）可以通过将super 调用直接放入方法引用适配器来避免合成访问器。

---

对封闭类型的超类方法的方法引用

class T {
    class U {
        class V {{
            Supplier<?> s;
/*4*/       s = T.super::toString;
        }}
    }
}

如您所料，这是前面两种情况的组合：

class T {
    static synthetic String access$0(T t) { // executing accessor
        return t.super.toString(); // only for the refered outer class
    }
    class U { // new U(T.this)
        static synthetic T access$0(U u) { // relaying accessor
            return T.this; // for every intermediate outer class
        }
        class V { // new V(U.this)
            dynamic bootstrap Supplier get(T t) { // methodref
                return () -> T.access$0(t); // toString() adapted to get()
            }
            {
                get(U.access$0(U.this)); // get(T.this)
            }
        }
    }
}

这里没有什么新东西，只是注意内部类总是只接收直接外部类的实例，所以在类V中，使用T.this可能会遍历整个中间合成访问器方法链，例如U.access$0(V.U_this)（如 Eclipse 中），或利用这些合成字段的包可见性（引用 outer.this）并将 T.this 转换为 V.U_this.T_this（如 OpenJDK ）。

---

N.B.：以上翻译是根据 Eclipse 编译器。 OpenJDK 的不同之处在于为方法引用生成 instance 合成 lambda 方法，而不是像 Eclipse 那样生成 static 合成访问器方法，并且还避免了访问器链，因此在最后一种情况下 OpenJDK 发出：

class T {
    static synthetic String access$0(T t) { // executing accessor
        return t.super.toString(); // only for the refered outer class
    }
    class U { // new U(T.this)
        class V { // new V(U.this)
            instance synthetic Object lambda$0() {
                return T.access$0(V.U_this.T_this); // direct relay
            }
            dynamic bootstrap Supplier get(V v) { // methodref
                return () -> V.lambda$0(v); // lambda$0() adapted to get()
            }
            {
                get(V.this);
            }
        }
    }
}

---

总而言之，它非常依赖于编译器供应商。

Answer 2

super.method() 形式的调用允许绕过同一类中的覆盖method()，调用超类层次结构中最具体的method()。因为，在字节码级别，只有声明类本身可以忽略它自己的覆盖方法（以及子类的潜在覆盖方法），如果这种调用应该由不同的（但概念上称为) 类，就像它的内部类之一一样，使用Outer.super.method(...) 形式，或为方法引用生成的合成类。

请注意，即使一个类没有覆盖被调用的方法并且似乎没有任何区别，调用也必须以这种方式编译，因为在运行时可能有子类覆盖该方法，然后，它会有所作为.

有趣的是，当T 实际上不是外部类而是包含语句的类时，使用T.super.method() 时会发生同样的事情。在这种情况下，辅助方法并不是必需的，但编译器似乎统一实现了identifier.super.method(...) 形式的所有调用。

---

附带说明，Oracle 的 JRE 在为 lambda 表达式/方法引用生成类时能够绕过此字节码限制，因此，super::methodName 类型的方法引用不需要访问器方法，可以显示如下：

import java.lang.invoke.*;
import java.util.function.Supplier;

public class LambdaSuper {
    public static void main(String[] args) throws Throwable {
        MethodHandles.Lookup l=MethodHandles.lookup();
        MethodType mt=MethodType.methodType(String.class);
        MethodHandle target=l.findSpecial(Object.class, "toString", mt, LambdaSuper.class);
        Supplier<String> s=(Supplier)LambdaMetafactory.metafactory(l, "get",
            MethodType.methodType(Supplier.class, LambdaSuper.class),
            mt.generic(), target, mt).getTarget().invokeExact(new LambdaSuper());
        System.out.println(s.get());
    }

    @Override
    public String toString() {
        return "overridden method";
    }
}

生成的Supplier 将返回类似LambdaSuper@6b884d57 的内容，表明它调用了覆盖的Object.toString() 方法而不是覆盖的LambdaSuper.toString()。编译器供应商似乎对 JRE 功能的期望很谨慎，不幸的是，这部分似乎有点未指定。

不过，对于真正的内部类场景，它们是必需的。