13

考虑以下一组表达式：

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？我希望 line/*2*/和 bootstrap 方法用于线路/*3*/，并且/*4*/也可以invokespecial像线路/*1*/一样使用。

特别是当方法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？

4

2 回答 2

5

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

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

有趣的是，当使用T.super.method()whenT实际上不是外部类而是包含该语句的类时，也会发生同样的事情。在这种情况下，辅助方法并不是真正需要的，但编译器似乎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 功能的期望很谨慎，不幸的是，这部分似乎有点未指定。

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

于 2016-01-08T11:16:06.263 回答
0

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)
            }
        }
    }
}

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

注意：以上翻译是根据Eclipse编译器。OpenJDK的不同之处在于为方法引用生成实例合成 lambda 方法，而不是像Eclipse那样静态合成访问器方法，并且还避免了访问器链，因此在最后一种情况下，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);
            }
        }
    }
}

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

于 2016-01-08T18:02:54.057 回答