Почему «T.super.toString()» и «super::toString» используют синтетический метод доступа?

Вызов формы super.method() позволяет обойти переопределяющий method() в том же классе, вызывая наиболее конкретный method() иерархии суперкласса. Поскольку на уровне байтового кода только сам объявляющий класс может игнорировать свой собственный переопределяющий метод (и потенциальные переопределяющие методы подклассов), будет сгенерирован искусственный метод доступа, если этот вид вызова должен быть выполнен другим (но концептуально названным ) класс, как один из его внутренних классов, используя форму Outer.super.method(...), или синтетический класс, сгенерированный для ссылки на метод.

Обратите внимание, что даже если класс не переопределяет вызываемый метод и кажется, что это не имеет значения, вызов должен быть скомпилирован таким образом, поскольку во время выполнения могут быть подклассы, переопределяющие метод, и тогда это будет иметь значение.

Интересно, что то же самое происходит при использовании T.super.method(), когда T на самом деле является не внешним классом, а классом, содержащим оператор. В этом случае вспомогательный метод на самом деле не нужен, но кажется, что компилятор реализует все вызовы формы identifier.super.method(...) единообразно.

В качестве примечания, Oracle JRE способна обойти это ограничение байт-кода при создании классов для лямбда-выражений/ссылок на методы, поэтому методы доступа не нужны для ссылок на методы вида 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, и, к сожалению, эта часть немного недоопределена.

Тем не менее, для реальных сценариев внутреннего класса они требуются.

Хольгер уже объяснил, почему это происходит 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 (т.е. в самом себе, что кажется лишним) генерируется только "исполняющий" аксессор.

N.B.: Цепочка доступа создается 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.

N.B.: Здесь только 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).

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