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

Ответ 1

Вызов формы 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 возвращает что-то похожее [email protected], показывающее, что он вызывает переопределенный метод Object.toString(), а не переопределяющий LambdaSuper.toString(). Похоже, что поставщики компилятора внимательно следят за тем, что ожидать от возможностей JRE, и, к сожалению, эта часть немного отстала.

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

Ответ 2

Хольгер уже объяснил , почему это происходит — 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.

NB: здесь только 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);
            }
        }
    }
}