Класс MethodHandle

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

Если символьный описатель типа места вызова точно соответствует type обработчика метода, вызов происходит так же, как если бы он был выполнен с помощью invokeExact.

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

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

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

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

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

• Определить длину массива аргументов как N. Для ссылки null, 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 ядра Reflection и 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
• вызов метода lookup, который разрешается до 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 могут добавить дополнительную информацию в строковое представление. Поэтому текущий синтаксис не должен анализироваться приложениями.)