added in API level 26

MethodHandleInfo

public interface MethodHandleInfo

java.lang.invoke.MethodHandleInfo

A symbolic reference obtained by cracking a direct method handle into its consitutent symbolic parts. To crack a direct method handle, call Lookup.revealDirect.

Direct Method Handles

A direct method handle represents a method, constructor, or field without any intervening argument bindings or other transformations. The method, constructor, or field referred to by a direct method handle is called its underlying member. Direct method handles may be obtained in any of these ways:

By executing an ldc instruction on a CONSTANT_MethodHandle constant. (See the Java Virtual Machine Specification, sections 4.4.8 and 5.4.3.)
By calling one of the Lookup Factory Methods, such as Lookup.findVirtual, to resolve a symbolic reference into a method handle. A symbolic reference consists of a class, name string, and type.
By calling the factory method Lookup.unreflect or Lookup.unreflectSpecial to convert a Method into a method handle.
By calling the factory method Lookup.unreflectConstructor to convert a Constructor into a method handle.
By calling the factory method Lookup.unreflectGetter or Lookup.unreflectSetter to convert a Field into a method handle.

Restrictions on Cracking

Given a suitable Lookup object, it is possible to crack any direct method handle to recover a symbolic reference for the underlying method, constructor, or field. Cracking must be done via a Lookup object equivalent to that which created the target method handle, or which has enough access permissions to recreate an equivalent method handle.

If the underlying method is caller sensitive, the direct method handle will have been "bound" to a particular caller class, the lookup class of the lookup object used to create it. Cracking this method handle with a different lookup class will fail even if the underlying method is public (like Class.forName).

The requirement of lookup object matching provides a "fast fail" behavior for programs which may otherwise trust erroneous revelation of a method handle with symbolic information (or caller binding) from an unexpected scope. Use reflectAs(Class, MethodHandle) to override this limitation.

Reference kinds

The Lookup Factory Methods correspond to all major use cases for methods, constructors, and fields. These use cases may be distinguished using small integers as follows:

reference kind	descriptive name	scope	member	behavior
`1`	`REF_getField`	`class`	`FT f;`	`(T) this.f;`
`2`	`REF_getStatic`	`class` or `interface`	`static` `FT f;`	`(T) C.f;`
`3`	`REF_putField`	`class`	`FT f;`	`this.f = x;`
`4`	`REF_putStatic`	`class`	`static` `FT f;`	`C.f = arg;`
`5`	`REF_invokeVirtual`	`class`	`T m(A*);`	`(T) this.m(arg*);`
`6`	`REF_invokeStatic`	`class` or `interface`	`static` `T m(A*);`	`(T) C.m(arg*);`
`7`	`REF_invokeSpecial`	`class` or `interface`	`T m(A*);`	`(T) super.m(arg*);`
`8`	`REF_newInvokeSpecial`	`class`	`C(A*);`	`new C(arg*);`
`9`	`REF_invokeInterface`	`interface`	`T m(A*);`	`(T) this.m(arg*);`

Summary

Constants
`int`	`REF_getField` A direct method handle reference kind, as defined in the table above.
`int`	`REF_getStatic` A direct method handle reference kind, as defined in the table above.
`int`	`REF_invokeInterface` A direct method handle reference kind, as defined in the table above.
`int`	`REF_invokeSpecial` A direct method handle reference kind, as defined in the table above.
`int`	`REF_invokeStatic` A direct method handle reference kind, as defined in the table above.
`int`	`REF_invokeVirtual` A direct method handle reference kind, as defined in the table above.
`int`	`REF_newInvokeSpecial` A direct method handle reference kind, as defined in the table above.
`int`	`REF_putField` A direct method handle reference kind, as defined in the table above.
`int`	`REF_putStatic` A direct method handle reference kind, as defined in the table above.

Public methods
`abstract Class<?>`	`getDeclaringClass()` Returns the class in which the cracked method handle's underlying member was defined.
`abstract MethodType`	`getMethodType()` Returns the nominal type of the cracked symbolic reference, expressed as a method type.
`abstract int`	`getModifiers()` Returns the access modifiers of the underlying member.
`abstract String`	`getName()` Returns the name of the cracked method handle's underlying member.
`abstract int`	`getReferenceKind()` Returns the reference kind of the cracked method handle, which in turn determines whether the method handle's underlying member was a constructor, method, or field.
`default boolean`	`isVarArgs()` Determines if the underlying member was a variable arity method or constructor.
`static boolean`	`refKindIsField(int refKind)`
`static boolean`	`refKindIsValid(int refKind)`
`static String`	`refKindName(int refKind)`
`static String`	`referenceKindToString(int referenceKind)` Returns the descriptive name of the given reference kind, as defined in the table above.
`abstract <T extends Member> T`	`reflectAs(Class<T> expected, MethodHandles.Lookup lookup)` Reflects the underlying member as a method, constructor, or field object.
`static String`	`toString(int kind, Class<?> defc, String name, MethodType type)` Returns a string representation for a `MethodHandleInfo`, given the four parts of its symbolic reference.