Module java.base

Interface MethodHandleInfo

  • public interface 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:

    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 MethodHandles.reflectAs(java.lang.Class<T>, java.lang.invoke.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 kinds
    reference kinddescriptive namescopememberbehavior
    1REF_getFieldclass FT f;(T) this.f;
    2REF_getStaticclass or interface static
    FT f;
    (T) C.f;
    3REF_putFieldclass FT f;this.f = x;
    4REF_putStaticclass static
    FT f;
    C.f = arg;
    5REF_invokeVirtualclass T m(A*);(T) this.m(arg*);
    6REF_invokeStaticclass or interface static
    T m(A*);
    (T) C.m(arg*);
    7REF_invokeSpecialclass or interface T m(A*);(T) super.m(arg*);
    8REF_newInvokeSpecialclass C(A*);new C(arg*);
    9REF_invokeInterfaceinterface T m(A*);(T) this.m(arg*);
    • Method Detail

      • getReferenceKind

        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. See the table above for definitions.
        the integer code for the kind of reference used to access the underlying member
      • getDeclaringClass

        Class<?> getDeclaringClass()
        Returns the class in which the cracked method handle's underlying member was defined.
        the declaring class of the underlying member
      • getName

        String getName()
        Returns the name of the cracked method handle's underlying member. This is "<init>" if the underlying member was a constructor, else it is a simple method name or field name.
        the simple name of the underlying member
      • getMethodType

        MethodType getMethodType()
        Returns the nominal type of the cracked symbolic reference, expressed as a method type. If the reference is to a constructor, the return type will be void. If it is to a non-static method, the method type will not mention the this parameter. If it is to a field and the requested access is to read the field, the method type will have no parameters and return the field type. If it is to a field and the requested access is to write the field, the method type will have one parameter of the field type and return void.

        Note that original direct method handle may include a leading this parameter, or (in the case of a constructor) will replace the void return type with the constructed class. The nominal type does not include any this parameter, and (in the case of a constructor) will return void.

        the type of the underlying member, expressed as a method type
      • reflectAs

        <T extends Member> T reflectAs​(Class<T> expected,
                                       MethodHandles.Lookup lookup)
        Reflects the underlying member as a method, constructor, or field object. If the underlying member is public, it is reflected as if by getMethod, getConstructor, or getField. Otherwise, it is reflected as if by getDeclaredMethod, getDeclaredConstructor, or getDeclaredField. The underlying member must be accessible to the given lookup object.
        Type Parameters:
        T - the desired type of the result, either Member or a subtype
        expected - a class object representing the desired result type T
        lookup - the lookup object that created this MethodHandleInfo, or one with equivalent access privileges
        a reference to the method, constructor, or field object
        ClassCastException - if the member is not of the expected type
        NullPointerException - if either argument is null
        IllegalArgumentException - if the underlying member is not accessible to the given lookup object
      • isVarArgs

        default boolean isVarArgs()
        Determines if the underlying member was a variable arity method or constructor. Such members are represented by method handles that are varargs collectors.
        Implementation Requirements:
        This produces a result equivalent to:
             getReferenceKind() >= REF_invokeVirtual && Modifier.isTransient(getModifiers())
        true if and only if the underlying member was declared with variable arity.
      • referenceKindToString

        static String referenceKindToString​(int referenceKind)
        Returns the descriptive name of the given reference kind, as defined in the table above. The conventional prefix "REF_" is omitted.
        referenceKind - an integer code for a kind of reference used to access a class member
        a mixed-case string such as "getField"
        IllegalArgumentException - if the argument is not a valid reference kind number