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