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

При наблюдении этого метода через 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.

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

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

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

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

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 - примитивным типом, то в runtime будет применено преобразование распаковки, возможно, за которым следует преобразование вызова 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.

Создаёт обработчик метода для распределения массива, принимающий аргумент-массив в конце и распределяющий его элементы как позиционные аргументы. Новый обработчик метода адаптирует текущий обработчик метода как свой целевой обработчик. Тип адаптера будет таким же, как тип целевого, за исключением того, что последние arrayLength параметры типа целевого обработчика будут заменены единственным параметром-массивом типа arrayType.

Если тип элемента массива отличается от любого из соответствующих типов аргументов в исходном целевом обработчике, исходный целевой обработчик адаптируется для непосредственного приёма элементов массива, как если бы был вызван 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()));

Создаёт обработчик метода для распределения массива, принимающий аргумент-массив в заданной позиции и распределяющий его элементы как позиционные аргументы вместо массива. Новый обработчик метода адаптирует текущий обработчик метода как свой целевой обработчик. Тип адаптера будет таким же, как тип целевого, за исключением того, что arrayLength параметры типа целевого обработчика, начиная с нулевой позиции spreadArgPos, заменяются единственным параметром-массивом типа arrayType.

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

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

Если тип массива отличается от типа конечного аргумента в исходном целевом обработчике, исходный целевой обработчик адаптируется для работы непосредственно с типом массива, как если бы был вызван 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));

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

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

Этот метод работает очень похоже на 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.

В противном случае, результирующий обработчик метода с фиксированной арностью имеет тот же тип и поведение, что и текущий обработчик метода, за исключением того, что 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 в качестве нового ведущего аргумента целевому объекту. Другие аргументы также передаются без изменений. То, что целевой объект возвращает в конечном итоге, возвращается связанным обработчиком без изменений.

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

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

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

Возвращает строковое представление обработчика метода, начинающееся со строки "MethodHandle" и заканчивающееся строковым представлением типа обработчика метода. Другими словами, этот метод возвращает строку, равную значению:

"MethodHandle" + type().toString()

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