Класс MethodHandle

При просмотре этого метода через API базовой рефлексии он будет выглядеть как один нативный метод, принимающий массив объектов и возвращающий объект. При прямом вызове этого нативного метода через java.lang.reflect.Method.invoke, через JNI или косвенно через Lookup.unreflect будет выброшено исключение UnsupportedOperationException.

Если символьный дескриптор типа точки вызова точно совпадает с type этого дескриптора метода, вызов выполняется так же, как посредством invokeExact.

В противном случае вызов выполняется так, как если бы этот дескриптор метода сначала был адаптирован посредством вызова asType, чтобы привести его к требуемому типу, а затем вызов выполнялся так же, как посредством invokeExact для адаптированного дескриптора метода.

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

Разрешённый дескриптор типа в точке вызова invoke должен быть допустимым аргументом метода-получателя asType. В частности, вызывающий код должен указать то же количество аргументов, что и тип вызываемого метода, если вызываемый метод не является сборщиком аргументов переменной длины.

При просмотре этого метода через API базовой рефлексии он будет выглядеть как один нативный метод, принимающий массив объектов и возвращающий объект. При прямом вызове этого нативного метода через java.lang.reflect.Method.invoke, через JNI или косвенно через Lookup.unreflect будет выброшено исключение UnsupportedOperationException.

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

• Определить длину массива аргументов как N. Для нулевой ссылки — N=0.
• Собрать N элементов массива в логический список аргументов, статический тип каждого аргумента — Object.
• Определить число параметров типа этого дескриптора метода как M.
• Определить общий тип TN для N аргументов или M аргументов, если это число меньше N, как TN=MethodType.genericMethodType(Math.min(N, M)).
• Если N больше M, выполнить следующие проверки и действия, чтобы сократить логический список аргументов:
  • Проверить, имеет ли этот дескриптор метода переменную арность и завершающий параметр некоторого типа массива A[]. Если нет, завершиться с ошибкой WrongMethodTypeException.
  • Собрать завершающие элементы (их N-M+1) логического списка аргументов в один массив типа A[], используя преобразования asType для приведения каждого завершающего аргумента к типу A.
  • Если какое-либо из этих преобразований невозможно, завершиться с ошибкой ClassCastException, если какой-либо завершающий элемент нельзя привести к A, либо с ошибкой NullPointerException, если какой-либо завершающий элемент имеет значение null, а A не является ссылочным типом.
  • Заменить логические аргументы, собранные в массив типа A[], самим массивом, сократив тем самым список аргументов до длины M. Этот последний аргумент сохраняет статический тип A[].
  • Изменить тип TN, заменив тип параметра N с Object на A[].
• Привести исходный целевой дескриптор метода MH0 к требуемому типу, как MH1 = MH0.asType(TN).
• Развернуть список аргументов в N отдельных аргументов A0, ....
• Вызвать дескриптор метода с приведённым типом и развёрнутыми аргументами: MH1.invokeExact(A0, ...).
• Принять возвращаемое значение как ссылку Object.

Если целевой дескриптор метода имеет переменную арность и список аргументов длиннее этой арности, избыточные аргументы, начиная с позиции завершающего аргумента-массива, будут собраны (если возможно, посредством преобразований asType) в массив соответствующего типа, после чего вызов продолжится с сокращённым списком аргументов. Таким образом, списки аргументов большого размера, которые при развёртывании заняли бы более 254 слотов, всё равно можно обрабатывать единообразно.

В отличие от режима вызова generic, который может «повторно использовать» аргумент-массив, передавая его непосредственно целевому методу, этот режим вызова всегда создаёт новый параметр-массив, даже если исходный массив, переданный в invokeWithArguments, можно было бы использовать как непосредственный аргумент целевого метода. Даже если число M фактических аргументов равно арности N, а последний аргумент во время выполнения является подходящим массивом типа A[], он всё равно будет упакован в новый массив из одного элемента, поскольку точка вызова статически задаёт тип аргумента как Object, а не как тип массива. Это не особое правило для данного метода, а обычное следствие правил вызова с переменной арностью.

Вследствие действия шага asType при необходимости применяются следующие преобразования аргументов:

• приведение ссылок
• распаковка
• расширяющие преобразования примитивов
• преобразование переменной арности

Возвращённое вызовом значение упаковывается, если оно является примитивом, либо заменяется на null, если тип возвращаемого значения — void.

В отличие от полиморфных по сигнатуре методов invokeExact и invoke, к invokeWithArguments можно обращаться обычным образом через API базовой рефлексии и JNI. Поэтому его можно использовать как мост между нативным или рефлексивным кодом и дескрипторами методов.

Этот метод также эквивалентен следующему коду:

  invokeWithArguments(arguments.toArray())

Если этот дескриптор метода имеет переменную арность, допускаются списки большого размера. Подробнее см. invokeWithArguments(Object[]).

Если исходный и новый типы равны, возвращает this.

При вызове новый дескриптор метода выполнит следующие действия:

• Преобразует входящий список аргументов в соответствии со списком аргументов исходного дескриптора метода.
• Вызывает исходный дескриптор метода с преобразованным списком аргументов.
• Преобразует результат, возвращённый исходным дескриптором метода, в тип возвращаемого значения нового дескриптора метода.

Этот метод обеспечивает принципиальное поведенческое различие между invokeExact и обычным неточным invoke. Эти два метода выполняют одни и те же действия, когда дескриптор типа вызывающего кода точно совпадает с типом вызываемого метода, но при несовпадении типов обычный invoke также вызывает asType (или какой-либо внутренний эквивалент), чтобы согласовать типы вызывающего кода и вызываемого метода.

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

Пусть T0 и T1 — соответствующие типы нового и старого параметров либо старого и нового возвращаемых значений. В частности, для некоторого допустимого индекса i пусть T0=newType.parameterType(i) и T1=this.type().parameterType(i). Либо, в обратном порядке для возвращаемых значений, пусть T0=this.type().returnType() и T1=newType.returnType(). Если типы совпадают, новый дескриптор метода не изменяет соответствующий аргумент или возвращаемое значение (если оно есть). В противном случае, если возможно, применяется одно из следующих преобразований:

• Если T0 и T1 являются ссылочными типами, выполняется приведение к T1. (Типы не обязаны быть каким-либо образом связаны. Это объясняется тем, что динамическое значение null можно преобразовать в любой ссылочный тип.)
• Если T0 и T1 являются примитивами, применяется преобразование вызова метода Java (JLS §5.3), если оно существует. (В частности, T0 должен преобразовываться в T1 посредством расширяющего преобразования примитивов.)
• Если T0 является примитивом, а T1 — ссылочным типом, применяется преобразование приведения Java (JLS §5.5), если оно существует. (В частности, значение упаковывается из T0 в соответствующий класс-обёртку, который затем при необходимости расширяется до T1.)
• Если T0 является ссылочным типом, а T1 — примитивом, во время выполнения применяется распаковка, за которой может следовать преобразование вызова метода Java (JLS §5.3) к значению-примитиву. (Это расширяющие преобразования примитивов.) T0 должен быть классом-обёрткой или его супертипом. (Если T0 — Object, это преобразования, допускаемые методом java.lang.reflect.Method.invoke.) Распаковка должна иметь возможность завершиться успешно: если T0 сам не является классом-обёрткой, должен существовать хотя бы один класс-обёртка TW, являющийся подтипом T0, значение-примитив которого после распаковки можно расширить до T1.
• Если тип возвращаемого значения T1 обозначен как void, любое возвращённое значение отбрасывается
• Если тип возвращаемого значения T0 — void, а T1 является ссылочным типом, вводится значение null.
• Если тип возвращаемого значения T0 — void, а T1 является примитивом, вводится нулевое значение.

Адаптацию дескриптора метода невозможно выполнить, если хотя бы одно из необходимых попарных преобразований невозможно.

Во время выполнения преобразования ссылочных аргументов или возвращаемых значений могут потребовать дополнительных проверок, которые могут завершиться неудачей. Операция распаковки может завершиться неудачей, если исходная ссылка равна null, в результате чего возникает NullPointerException. Операция распаковки или приведения ссылки также может завершиться неудачей, если ссылка указывает на объект неправильного типа, в результате чего возникает ClassCastException. Хотя операция распаковки может принимать несколько типов обёрток, если ни один из них не подходит, будет выброшено ClassCastException.

Если тип элемента массива отличается от какого-либо соответствующего типа аргумента исходного целевого объекта, исходный целевой объект адаптируется для непосредственного приёма элементов массива, как если бы был вызван метод asType.

При вызове адаптер заменяет завершающий аргумент-массив его элементами, каждый из которых передаётся целевому объекту как отдельный аргумент. (Порядок аргументов сохраняется.) Они попарно преобразуются посредством приведения и/или распаковки к типам завершающих параметров целевого объекта. Затем вызывается целевой объект. Возвращаемое им значение адаптер передаёт без изменений.

Перед вызовом целевого объекта адаптер проверяет, содержит ли массив ровно столько элементов, сколько необходимо для правильного числа аргументов целевого дескриптора метода. (Если требуется ноль элементов, массив также может быть null.)

При вызове адаптера длина переданного аргумента array запрашивается так, как если бы использовался байткод array.length или arraylength. Если адаптер принимает завершающий аргумент-массив нулевой длины, переданный аргумент array может быть либо массивом нулевой длины, либо null; в противном случае адаптер выбросит NullPointerException, если массив равен null, и выбросит IllegalArgumentException, если массив содержит неверное число элементов.

Вот несколько простых примеров дескрипторов методов, распределяющих элементы массива:

MethodHandle equals = publicLookup()
  .findVirtual(String.class, "equals", methodType(boolean.class, Object.class));
assert( (boolean) equals.invokeExact("me", (Object)"me"));
assert(!(boolean) equals.invokeExact("me", (Object)"thee"));
// spread both arguments from a 2-array:
MethodHandle eq2 = equals.asSpreader(Object[].class, 2);
assert( (boolean) eq2.invokeExact(new Object[]{ "me", "me" }));
assert(!(boolean) eq2.invokeExact(new Object[]{ "me", "thee" }));
// try to spread from anything but a 2-array:
for (int n = 0; n <= 10; n++) {
  Object[] badArityArgs = (n == 2 ? new Object[0] : new Object[n]);
  try { assert((boolean) eq2.invokeExact(badArityArgs) && false); }
  catch (IllegalArgumentException ex) { } // OK
}
// spread both arguments from a String array:
MethodHandle eq2s = equals.asSpreader(String[].class, 2);
assert( (boolean) eq2s.invokeExact(new String[]{ "me", "me" }));
assert(!(boolean) eq2s.invokeExact(new String[]{ "me", "thee" }));
// spread second arguments from a 1-array:
MethodHandle eq1 = equals.asSpreader(Object[].class, 1);
assert( (boolean) eq1.invokeExact("me", new Object[]{ "me" }));
assert(!(boolean) eq1.invokeExact("me", new Object[]{ "thee" }));
// spread no arguments from a 0-array or null:
MethodHandle eq0 = equals.asSpreader(Object[].class, 0);
assert( (boolean) eq0.invokeExact("me", (Object)"me", new Object[0]));
assert(!(boolean) eq0.invokeExact("me", (Object)"thee", (Object[])null));
// asSpreader and asCollector are approximate inverses:
for (int n = 0; n <= 2; n++) {
    for (Class<?> a : new Class<?>[]{Object[].class, String[].class, CharSequence[].class}) {
        MethodHandle equals2 = equals.asSpreader(a, n).asCollector(a, n);
        assert( (boolean) equals2.invokeWithArguments("me", "me"));
        assert(!(boolean) equals2.invokeWithArguments("me", "thee"));
    }
}
MethodHandle caToString = publicLookup()
  .findStatic(Arrays.class, "toString", methodType(String.class, char[].class));
assertEquals("[A, B, C]", (String) caToString.invokeExact("ABC".toCharArray()));
MethodHandle caString3 = caToString.asCollector(char[].class, 3);
assertEquals("[A, B, C]", (String) caString3.invokeExact('A', 'B', 'C'));
MethodHandle caToString2 = caString3.asSpreader(char[].class, 2);
assertEquals("[A, B, C]", (String) caToString2.invokeExact('A', "BC".toCharArray()));

Этот метод очень похож на asSpreader(Class, int), но принимает дополнительный аргумент spreadArgPos, указывающий позицию в списке параметров, с которой следует начать распределение.

Если тип массива отличается от типа последнего аргумента исходного целевого объекта, исходный целевой объект адаптируется для непосредственного приёма массива, как если бы был вызван метод asType.

При вызове адаптер заменяет свои завершающие аргументы arrayLength одним новым массивом типа arrayType, элементы которого состоят из заменённых аргументов в исходном порядке. Затем вызывается целевой объект. Возвращаемое им значение адаптер передаёт без изменений.

(Если arrayLength равно нулю, массив также может быть общей константой.)

(Примечание: arrayType часто совпадает с типом последнего параметра исходного целевого объекта. Этот аргумент указан явно для симметрии с asSpreader, а также чтобы целевой объект мог использовать простой Object в качестве типа последнего параметра.)

Чтобы создать собирающий адаптер, не ограниченный определённым числом собираемых аргументов, используйте вместо этого asVarargsCollector или withVarargs.

Вот несколько примеров дескрипторов методов, собирающих аргументы в массив:

MethodHandle deepToString = publicLookup()
  .findStatic(Arrays.class, "deepToString", methodType(String.class, Object[].class));
assertEquals("[won]",   (String) deepToString.invokeExact(new Object[]{"won"}));
MethodHandle ts1 = deepToString.asCollector(Object[].class, 1);
assertEquals(methodType(String.class, Object.class), ts1.type());
//assertEquals("[won]", (String) ts1.invokeExact(         new Object[]{"won"})); //FAIL
assertEquals("[[won]]", (String) ts1.invokeExact((Object) new Object[]{"won"}));
// arrayType can be a subtype of Object[]
MethodHandle ts2 = deepToString.asCollector(String[].class, 2);
assertEquals(methodType(String.class, String.class, String.class), ts2.type());
assertEquals("[two, too]", (String) ts2.invokeExact("two", "too"));
MethodHandle ts0 = deepToString.asCollector(Object[].class, 0);
assertEquals("[]", (String) ts0.invokeExact());
// collectors can be nested, Lisp-style
MethodHandle ts22 = deepToString.asCollector(Object[].class, 3).asCollector(String[].class, 2);
assertEquals("[A, B, [C, D]]", ((String) ts22.invokeExact((Object)'A', (Object)"B", "C", "D")));
// arrayType can be any primitive array type
MethodHandle bytesToString = publicLookup()
  .findStatic(Arrays.class, "toString", methodType(String.class, byte[].class))
  .asCollector(byte[].class, 3);
assertEquals("[1, 2, 3]", (String) bytesToString.invokeExact((byte)1, (byte)2, (byte)3));
MethodHandle longsToString = publicLookup()
  .findStatic(Arrays.class, "toString", methodType(String.class, long[].class))
  .asCollector(long[].class, 1);
assertEquals("[123]", (String) longsToString.invokeExact((long)123));

Примечание: Результирующий адаптер никогда не является дескриптором метода с переменной арностью, даже если исходный целевой дескриптор метода имел переменную арность.

Этот метод во многом похож на asCollector(Class, int), но отличается тем, что его аргумент collectArgPos указывает позицию в списке параметров, начиная с которой следует собирать аргументы. Индекс отсчитывается от нуля.

Тип и поведение адаптера совпадают с типом и поведением целевого дескриптора, за исключением того, что определенные запросы invoke и asType могут приводить к сбору завершающих позиционных аргументов в завершающий параметр целевого дескриптора. Кроме того, типом последнего параметра адаптера будет arrayType, даже если тип последнего параметра целевого дескриптора отличается.

Это преобразование может вернуть this, если дескриптор метода уже допускает переменное число аргументов, а тип его завершающего параметра совпадает с arrayType.

При вызове с помощью invokeExact адаптер вызывает целевой дескриптор без изменений аргументов. (Примечание: Такое поведение отличается от поведения сборщика с фиксированным числом аргументов, поскольку он принимает целый массив неопределенной длины, а не фиксированное число аргументов.)

При обычном неточном вызове invoke, если тип вызывающего кода совпадает с типом адаптера, адаптер вызывает целевой дескриптор так же, как при invokeExact. (Это обычное поведение для invoke при совпадении типов.)

В противном случае, если арность вызывающего кода совпадает с арностью адаптера, а тип завершающего параметра вызывающего кода является ссылочным типом, идентичным типу завершающего параметра адаптера или допускающим присваивание этому типу, аргументы и возвращаемые значения преобразуются попарно, как при применении asType к дескриптору метода с фиксированным числом аргументов.

В противном случае арности различаются либо тип завершающего параметра адаптера не допускает присваивания ему соответствующего типа вызывающего кода. В этом случае адаптер заменяет все завершающие аргументы, начиная с исходной позиции завершающего аргумента, новым массивом типа arrayType, элементы которого составляют (в том же порядке) замененные аргументы.

Тип вызывающего кода должен предоставлять как минимум достаточное количество аргументов правильного типа, чтобы удовлетворить требование целевого дескриптора к позиционным аргументам, предшествующим завершающему аргументу-массиву. Таким образом, вызывающий код должен передать не менее N-1 аргументов, где N — арность целевого дескриптора. Кроме того, должны существовать преобразования входящих аргументов в аргументы целевого дескриптора. Как и при других вариантах использования обычного invoke, если эти базовые требования не выполняются, может быть вызвано исключение WrongMethodTypeException.

Во всех случаях адаптер возвращает без изменений значение, которое в итоге возвращает целевой дескриптор.

В последнем случае результат в точности совпадает с тем, как если бы целевой дескриптор метода был временно адаптирован с помощью сборщика с фиксированным числом аргументов до арности, требуемой типом вызывающего кода. (Как и при asCollector, если длина массива равна нулю, вместо нового массива может использоваться общая константа. Если подразумеваемый вызов asCollector выбросил бы исключение IllegalArgumentException или WrongMethodTypeException, вызов адаптера с переменным числом аргументов должен выбросить WrongMethodTypeException.)

Поведение asType также специализировано для адаптеров с переменным числом аргументов, чтобы сохранялся инвариант: обычный неточный вызов invoke всегда эквивалентен вызову asType для корректировки типа целевого дескриптора с последующим вызовом invokeExact. Поэтому адаптер с переменным числом аргументов реагирует на запрос asType созданием сборщика с фиксированным числом аргументов тогда и только тогда, когда адаптер и запрошенный тип различаются либо арностью, либо типом завершающего аргумента. Затем тип полученного сборщика с фиксированным числом аргументов при необходимости дополнительно корректируется до запрошенного типа путем попарного преобразования, как при повторном применении asType.

Если дескриптор метода получен выполнением инструкции ldc для константы CONSTANT_MethodHandle, а целевой метод помечен как метод с переменным числом аргументов (с помощью бита-модификатора 0x0080), дескриптор метода будет принимать различные значения арности, как если бы константа дескриптора метода была создана вызовом asVarargsCollector.

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

Никакие преобразования дескрипторов методов не создают новые дескрипторы методов с переменным числом аргументов, если это прямо не указано в документации. Поэтому, кроме asVarargsCollector и withVarargs, все методы в MethodHandle и MethodHandles возвращают дескриптор метода с фиксированным числом аргументов, за исключением случаев, когда указано, что они возвращают исходный операнд (например, asType с типом самого дескриптора метода).

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

Ниже приведен пример дескриптора метода с переменным числом аргументов, создающего список:

MethodHandle deepToString = publicLookup()
  .findStatic(Arrays.class, "deepToString", methodType(String.class, Object[].class));
MethodHandle ts1 = deepToString.asVarargsCollector(Object[].class);
assertEquals("[won]",   (String) ts1.invokeExact(    new Object[]{"won"}));
assertEquals("[won]",   (String) ts1.invoke(         new Object[]{"won"}));
assertEquals("[won]",   (String) ts1.invoke(                      "won" ));
assertEquals("[[won]]", (String) ts1.invoke((Object) new Object[]{"won"}));
// findStatic of Arrays.asList(...) produces a variable arity method handle:
MethodHandle asList = publicLookup()
  .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class));
assertEquals(methodType(List.class, Object[].class), asList.type());
assert(asList.isVarargsCollector());
assertEquals("[]", asList.invoke().toString());
assertEquals("[1]", asList.invoke(1).toString());
assertEquals("[two, too]", asList.invoke("two", "too").toString());
String[] argv = { "three", "thee", "tee" };
assertEquals("[three, thee, tee]", asList.invoke(argv).toString());
assertEquals("[three, thee, tee]", asList.invoke((Object[])argv).toString());
List ls = (List) asList.invoke((Object)argv);
assertEquals(1, ls.size());
assertEquals("[three, thee, tee]", Arrays.toString((Object[])ls.get(0)));

Обсуждение: Эти правила разработаны как вариант правил Java для методов с переменным числом аргументов с динамической типизацией. В обоих случаях вызывающий код может передать методу или дескриптору метода с переменным числом аргументов ноль или более позиционных аргументов либо заранее собранные массивы любой длины. Пользователям следует учитывать особую роль последнего аргумента и влияние совпадения типов этого последнего аргумента: от этого зависит, будет ли один завершающий аргумент интерпретироваться как целый массив или как отдельный элемент собираемого массива. Обратите внимание, что динамический тип завершающего аргумента не влияет на это решение; учитывается только сравнение символьного дескриптора типа точки вызова и дескриптора типа дескриптора метода.

• вызов asVarargsCollector
• вызов метода поиска, который разрешается в метод или конструктор Java с переменным числом аргументов
• инструкция ldc для CONSTANT_MethodHandle, которая разрешается в метод или конструктор Java с переменным числом аргументов

Если текущий дескриптор метода не допускает переменного числа аргументов, возвращается текущий дескриптор метода. Это верно, даже если текущий дескриптор метода не мог бы быть допустимым входным значением для asVarargsCollector.

В противном случае полученный дескриптор метода с фиксированным числом аргументов имеет тот же тип и поведение, что и текущий дескриптор метода, за исключением того, что isVarargsCollector будет возвращать false. Дескриптор метода с фиксированным числом аргументов может совпадать с предыдущим аргументом asVarargsCollector, а может и не совпадать.

Ниже приведен пример дескриптора метода с переменным числом аргументов, создающего список:

MethodHandle asListVar = publicLookup()
  .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class))
  .asVarargsCollector(Object[].class);
MethodHandle asListFix = asListVar.asFixedArity();
assertEquals("[1]", asListVar.invoke(1).toString());
Exception caught = null;
try { asListFix.invoke((Object)1); }
catch (Exception ex) { caught = ex; }
assert(caught instanceof ClassCastException);
assertEquals("[two, too]", asListVar.invoke("two", "too").toString());
try { asListFix.invoke("two", "too"); }
catch (Exception ex) { caught = ex; }
assert(caught instanceof WrongMethodTypeException);
Object[] argv = { "three", "thee", "tee" };
assertEquals("[three, thee, tee]", asListVar.invoke(argv).toString());
assertEquals("[three, thee, tee]", asListFix.invoke(argv).toString());
assertEquals(1, ((List) asListVar.invoke((Object)argv)).size());
assertEquals("[three, thee, tee]", asListFix.invoke((Object)argv).toString());

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

Ссылка x должна преобразовываться в тип первого параметра целевого дескриптора.

Примечание: Поскольку дескрипторы методов неизменяемы, целевой дескриптор метода сохраняет исходные тип и поведение.

Примечание: Полученный адаптер никогда не является дескриптором метода с переменным числом аргументов, даже если исходный целевой дескриптор метода был таким.

"MethodHandle" + type().toString()

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