Added in API level 26

MethodType

class MethodType : TypeDescriptor.OfMethod<Class<*>!, MethodType!>, Serializable
kotlin.Any
   ↳ java.lang.invoke.MethodType

A method type represents the arguments and return type accepted and returned by a method handle, or the arguments and return type passed and expected by a method handle caller. Method types must be properly matched between a method handle and all its callers, and the JVM's operations enforce this matching at, specifically during calls to MethodHandle.invokeExact and MethodHandle.invoke, and during execution of invokedynamic instructions.

The structure is a return type accompanied by any number of parameter types. The types (primitive, void, and reference) are represented by Class objects. (For ease of exposition, we treat void as if it were a type. In fact, it denotes the absence of a return type.)

All instances of MethodType are immutable. Two instances are completely interchangeable if they compare equal. Equality depends on pairwise correspondence of the return and parameter types and on nothing else.

This type can be created only by factory methods. All factory methods may cache values, though caching is not guaranteed. Some factory methods are static, while others are virtual methods which modify precursor method types, e.g., by changing a selected parameter.

Factory methods which operate on groups of parameter types are systematically presented in two versions, so that both Java arrays and Java lists can be used to work with groups of parameter types. The query methods parameterArray and parameterList also provide a choice between arrays and lists.

MethodType objects are sometimes derived from bytecode instructions such as invokedynamic, specifically from the type descriptor strings associated with the instructions in a class file's constant pool.

Like classes and strings, method types can also be represented directly in a class file's constant pool as constants. A method type may be loaded by an ldc instruction which refers to a suitable CONSTANT_MethodType constant pool entry. The entry refers to a CONSTANT_Utf8 spelling for the descriptor string. (For full details on method type constants, see sections 4.4.8 and 5.4.3.5 of the Java Virtual Machine Specification.)

When the JVM materializes a MethodType from a descriptor string, all classes named in the descriptor must be accessible, and will be loaded. (But the classes need not be initialized, as is the case with a CONSTANT_Class.) This loading may occur at any time before the MethodType object is first derived.

Summary

Public methods
MethodType!
appendParameterTypes(vararg ptypesToInsert: Class<*>!)

Finds or creates a method type with additional parameter types.

MethodType!
appendParameterTypes(ptypesToInsert: MutableList<Class<*>!>!)

Finds or creates a method type with additional parameter types.

MethodType!
changeParameterType(num: Int, nptype: Class<*>!)

Finds or creates a method type with a single different parameter type.

MethodType!
changeReturnType(nrtype: Class<*>!)

Finds or creates a method type with a different return type.

String

Returns a descriptor string for this method type.

MethodType!
dropParameterTypes(start: Int, end: Int)

Finds or creates a method type with some parameter types omitted.

Boolean
equals(other: Any?)

Compares the specified object with this type for equality.

MethodType!

Erases all reference types to Object.

static MethodType!

Finds or creates an instance of a method type, given the spelling of its bytecode descriptor.

MethodType!

Converts all types, both reference and primitive, to Object.

static MethodType!
genericMethodType(objectArgCount: Int, finalArray: Boolean)

Finds or creates a method type whose components are Object with an optional trailing Object[] array.

static MethodType!
genericMethodType(objectArgCount: Int)

Finds or creates a method type whose components are all Object.

Boolean

Reports if this type contains a primitive argument or return value.

Boolean

Reports if this type contains a wrapper argument or return value.

Int

Returns the hash code value for this method type.

MethodType!
insertParameterTypes(num: Int, vararg ptypesToInsert: Class<*>!)

Finds or creates a method type with additional parameter types.

MethodType!
insertParameterTypes(num: Int, ptypesToInsert: MutableList<Class<*>!>!)

Finds or creates a method type with additional parameter types.

Class<*>!

Returns the last parameter type of this method type.

static MethodType!
methodType(rtype: Class<*>!, ptypes: Array<Class<*>!>!)

Finds or creates an instance of the given method type.

static MethodType!
methodType(rtype: Class<*>!, ptypes: MutableList<Class<*>!>!)

Finds or creates a method type with the given components.

static MethodType!
methodType(rtype: Class<*>!, ptype0: Class<*>!, vararg ptypes: Class<*>!)

Finds or creates a method type with the given components.

static MethodType!
methodType(rtype: Class<*>!)

Finds or creates a method type with the given components.

static MethodType!
methodType(rtype: Class<*>!, ptype0: Class<*>!)

Finds or creates a method type with the given components.

static MethodType!
methodType(rtype: Class<*>!, ptypes: MethodType!)

Finds or creates a method type with the given components.

Array<Class<*>!>!

Presents the parameter types as an array (a convenience method).

Int

Returns the number of parameter types in this method type.

MutableList<Class<*>!>!

Presents the parameter types as a list (a convenience method).

Class<*>!

Returns the parameter type at the specified index, within this method type.

Class<*>!

Returns the return type of this method type.

String!

Produces a bytecode descriptor representation of the method type.

String

Returns a string representation of the method type, of the form "(PT0,PT1...)RT".

MethodType!

Converts all wrapper types to their corresponding primitive types.

MethodType!

Converts all primitive types to their corresponding wrapper types.

Public methods

appendParameterTypes

Added in API level 26
fun appendParameterTypes(vararg ptypesToInsert: Class<*>!): MethodType!

Finds or creates a method type with additional parameter types. Convenience method for methodType.

Parameters
ptypesToInsert Class<*>!: zero or more new parameter types to insert after the end of the parameter list
Return
MethodType! the same type, except with the selected parameter(s) appended
Exceptions
java.lang.IllegalArgumentException if any element of ptypesToInsert is void.class or if the resulting method type would have more than 255 parameter slots
java.lang.NullPointerException if ptypesToInsert or any of its elements is null

appendParameterTypes

Added in API level 26
fun appendParameterTypes(ptypesToInsert: MutableList<Class<*>!>!): MethodType!

Finds or creates a method type with additional parameter types. Convenience method for methodType.

Parameters
ptypesToInsert MutableList<Class<*>!>!: zero or more new parameter types to insert after the end of the parameter list
Return
MethodType! the same type, except with the selected parameter(s) appended
Exceptions
java.lang.IllegalArgumentException if any element of ptypesToInsert is void.class or if the resulting method type would have more than 255 parameter slots
java.lang.NullPointerException if ptypesToInsert or any of its elements is null

changeParameterType

Added in API level 26
fun changeParameterType(
    num: Int,
    nptype: Class<*>!
): MethodType!

Finds or creates a method type with a single different parameter type. Convenience method for methodType.

Parameters
index the index of the parameter to change
paramType a field descriptor describing the new parameter type
num Int: the index (zero-based) of the parameter type to change
nptype Class<*>!: a new parameter type to replace the old one with
Return
MethodType! the same type, except with the selected parameter changed
Exceptions
java.lang.NullPointerException if nptype is null
java.lang.IndexOutOfBoundsException if num is not a valid index into parameterArray()
java.lang.IllegalArgumentException if nptype is void.class

changeReturnType

Added in API level 26
fun changeReturnType(nrtype: Class<*>!): MethodType!

Finds or creates a method type with a different return type. Convenience method for methodType.

Parameters
newReturn a field descriptor for the new return type
nrtype Class<*>!: a return parameter type to replace the old one with
Return
MethodType! the same type, except with the return type change
Exceptions
java.lang.NullPointerException if nrtype is null

descriptorString

Added in API level 34
fun descriptorString(): String

Returns a descriptor string for this method type.

If this method type can be described nominally, then the result is a method type descriptor (JVMS {@jvms 4.3.3}).

If this method type cannot be described nominally and the result is a string of the form:

"(<parameter-descriptors>)<return-descriptor>" where <parameter-descriptors> is the concatenation of the descriptor string of all of the parameter types and the descriptor string of the return type.
Return
String the descriptor string for this method type

See Also

    dropParameterTypes

    Added in API level 26
    fun dropParameterTypes(
        start: Int,
        end: Int
    ): MethodType!

    Finds or creates a method type with some parameter types omitted. Convenience method for methodType.

    Parameters
    start Int: the index (zero-based) of the first parameter type to remove
    end Int: the index (greater than start) of the first parameter type after not to remove
    Return
    MethodType! the same type, except with the selected parameter(s) removed
    Exceptions
    java.lang.IndexOutOfBoundsException if start is negative or greater than parameterCount() or if end is negative or greater than parameterCount() or if start is greater than end

    equals

    Added in API level 26
    fun equals(other: Any?): Boolean

    Compares the specified object with this type for equality. That is, it returns true if and only if the specified object is also a method type with exactly the same parameters and return type.

    Parameters
    obj the reference object with which to compare.
    x object to compare
    Return
    Boolean true if this object is the same as the obj argument; false otherwise.

    erase

    Added in API level 26
    fun erase(): MethodType!

    Erases all reference types to Object. Convenience method for methodType. All primitive types (including void) will remain unchanged.

    Return
    MethodType! a version of the original type with all reference types replaced

    fromMethodDescriptorString

    Added in API level 26
    static fun fromMethodDescriptorString(
        descriptor: String!,
        loader: ClassLoader!
    ): MethodType!

    Finds or creates an instance of a method type, given the spelling of its bytecode descriptor. Convenience method for methodType. Any class or interface name embedded in the descriptor string will be resolved by calling ClassLoader#loadClass(java.lang.String) on the given loader (or if it is null, on the system class loader).

    Note that it is possible to encounter method types which cannot be constructed by this method, because their component types are not all reachable from a common class loader.

    This method is included for the benefit of applications that must generate bytecodes that process method handles and invokedynamic.

    Parameters
    descriptor String!: a bytecode-level type descriptor string "(T...)T"
    loader ClassLoader!: the class loader in which to look up the types
    Return
    MethodType! a method type matching the bytecode-level type descriptor
    Exceptions
    java.lang.NullPointerException if the string is null
    java.lang.IllegalArgumentException if the string is not well-formed
    java.lang.TypeNotPresentException if a named type cannot be found

    generic

    Added in API level 26
    fun generic(): MethodType!

    Converts all types, both reference and primitive, to Object. Convenience method for genericMethodType. The expression type.wrap().erase() produces the same value as type.generic().

    Return
    MethodType! a version of the original type with all types replaced

    genericMethodType

    Added in API level 26
    static fun genericMethodType(
        objectArgCount: Int,
        finalArray: Boolean
    ): MethodType!

    Finds or creates a method type whose components are Object with an optional trailing Object[] array. Convenience method for methodType. All parameters and the return type will be Object, except the final array parameter if any, which will be Object[].

    Parameters
    objectArgCount Int: number of parameters (excluding the final array parameter if any)
    finalArray Boolean: whether there will be a trailing array parameter, of type Object[]
    Return
    MethodType! a generally applicable method type, for all calls of the given fixed argument count and a collected array of further arguments
    Exceptions
    java.lang.IllegalArgumentException if objectArgCount is negative or greater than 255 (or 254, if finalArray is true)

    genericMethodType

    Added in API level 26
    static fun genericMethodType(objectArgCount: Int): MethodType!

    Finds or creates a method type whose components are all Object. Convenience method for methodType. All parameters and the return type will be Object.

    Parameters
    objectArgCount Int: number of parameters
    Return
    MethodType! a generally applicable method type, for all calls of the given argument count
    Exceptions
    java.lang.IllegalArgumentException if objectArgCount is negative or greater than 255

    hasPrimitives

    Added in API level 26
    fun hasPrimitives(): Boolean

    Reports if this type contains a primitive argument or return value. The return type void counts as a primitive.

    Return
    Boolean true if any of the types are primitives

    hasWrappers

    Added in API level 26
    fun hasWrappers(): Boolean

    Reports if this type contains a wrapper argument or return value. Wrappers are types which box primitive values, such as Integer. The reference type java.lang.Void counts as a wrapper, if it occurs as a return type.

    Return
    Boolean true if any of the types are wrappers

    hashCode

    Added in API level 26
    fun hashCode(): Int

    Returns the hash code value for this method type. It is defined to be the same as the hashcode of a List whose elements are the return type followed by the parameter types.

    Return
    Int the hash code value for this method type

    insertParameterTypes

    Added in API level 26
    fun insertParameterTypes(
        num: Int,
        vararg ptypesToInsert: Class<*>!
    ): MethodType!

    Finds or creates a method type with additional parameter types. Convenience method for methodType.

    Parameters
    pos the index at which to insert the first inserted parameter
    paramTypes field descriptors describing the new parameter types to insert
    num Int: the position (zero-based) of the inserted parameter type(s)
    ptypesToInsert Class<*>!: zero or more new parameter types to insert into the parameter list
    Return
    MethodType! the same type, except with the selected parameter(s) inserted
    Exceptions
    java.lang.NullPointerException if ptypesToInsert or any of its elements is null
    java.lang.IndexOutOfBoundsException if num is negative or greater than parameterCount()
    java.lang.IllegalArgumentException if any element of ptypesToInsert is void.class or if the resulting method type would have more than 255 parameter slots

    insertParameterTypes

    Added in API level 26
    fun insertParameterTypes(
        num: Int,
        ptypesToInsert: MutableList<Class<*>!>!
    ): MethodType!

    Finds or creates a method type with additional parameter types. Convenience method for methodType.

    Parameters
    num Int: the position (zero-based) of the inserted parameter type(s)
    ptypesToInsert MutableList<Class<*>!>!: zero or more new parameter types to insert into the parameter list
    Return
    MethodType! the same type, except with the selected parameter(s) inserted
    Exceptions
    java.lang.IndexOutOfBoundsException if num is negative or greater than parameterCount()
    java.lang.IllegalArgumentException if any element of ptypesToInsert is void.class or if the resulting method type would have more than 255 parameter slots
    java.lang.NullPointerException if ptypesToInsert or any of its elements is null

    lastParameterType

    Added in API level 33
    fun lastParameterType(): Class<*>!

    Returns the last parameter type of this method type. If this type has no parameters, the sentinel value void.class is returned instead.

    Return
    Class<*>! the last parameter type if any, else void.class

    methodType

    Added in API level 26
    static fun methodType(
        rtype: Class<*>!,
        ptypes: Array<Class<*>!>!
    ): MethodType!

    Finds or creates an instance of the given method type.

    Parameters
    rtype Class<*>!: the return type
    ptypes Array<Class<*>!>!: the parameter types
    Return
    MethodType! a method type with the given components
    Exceptions
    java.lang.NullPointerException if rtype or ptypes or any element of ptypes is null
    java.lang.IllegalArgumentException if any element of ptypes is void.class

    methodType

    Added in API level 26
    static fun methodType(
        rtype: Class<*>!,
        ptypes: MutableList<Class<*>!>!
    ): MethodType!

    Finds or creates a method type with the given components. Convenience method for methodType.

    Parameters
    rtype Class<*>!: the return type
    ptypes MutableList<Class<*>!>!: the parameter types
    Return
    MethodType! a method type with the given components
    Exceptions
    java.lang.NullPointerException if rtype or ptypes or any element of ptypes is null
    java.lang.IllegalArgumentException if any element of ptypes is void.class

    methodType

    Added in API level 26
    static fun methodType(
        rtype: Class<*>!,
        ptype0: Class<*>!,
        vararg ptypes: Class<*>!
    ): MethodType!

    Finds or creates a method type with the given components. Convenience method for methodType. The leading parameter type is prepended to the remaining array.

    Parameters
    rtype Class<*>!: the return type
    ptype0 Class<*>!: the first parameter type
    ptypes Class<*>!: the remaining parameter types
    Return
    MethodType! a method type with the given components
    Exceptions
    java.lang.NullPointerException if rtype or ptype0 or ptypes or any element of ptypes is null
    java.lang.IllegalArgumentException if ptype0 or ptypes or any element of ptypes is void.class

    methodType

    Added in API level 26
    static fun methodType(rtype: Class<*>!): MethodType!

    Finds or creates a method type with the given components. Convenience method for methodType. The resulting method has no parameter types.

    Parameters
    rtype Class<*>!: the return type
    Return
    MethodType! a method type with the given return value
    Exceptions
    java.lang.NullPointerException if rtype is null

    methodType

    Added in API level 26
    static fun methodType(
        rtype: Class<*>!,
        ptype0: Class<*>!
    ): MethodType!

    Finds or creates a method type with the given components. Convenience method for methodType. The resulting method has the single given parameter type.

    Parameters
    rtype Class<*>!: the return type
    ptype0 Class<*>!: the parameter type
    Return
    MethodType! a method type with the given return value and parameter type
    Exceptions
    java.lang.NullPointerException if rtype or ptype0 is null
    java.lang.IllegalArgumentException if ptype0 is void.class

    methodType

    Added in API level 26
    static fun methodType(
        rtype: Class<*>!,
        ptypes: MethodType!
    ): MethodType!

    Finds or creates a method type with the given components. Convenience method for methodType. The resulting method has the same parameter types as ptypes, and the specified return type.

    Parameters
    rtype Class<*>!: the return type
    ptypes MethodType!: the method type which supplies the parameter types
    Return
    MethodType! a method type with the given components
    Exceptions
    java.lang.NullPointerException if rtype or ptypes is null

    parameterArray

    Added in API level 26
    fun parameterArray(): Array<Class<*>!>!

    Presents the parameter types as an array (a convenience method). Changes to the array will not result in changes to the type.

    Return
    Array<Class<*>!>! the parameter types (as a fresh copy if necessary)

    parameterCount

    Added in API level 26
    fun parameterCount(): Int

    Returns the number of parameter types in this method type.

    Return
    Int the number of parameter types

    parameterList

    Added in API level 26
    fun parameterList(): MutableList<Class<*>!>!

    Presents the parameter types as a list (a convenience method). The list will be immutable.

    Return
    MutableList<Class<*>!>! the parameter types (as an immutable list)

    parameterType

    Added in API level 26
    fun parameterType(num: Int): Class<*>!

    Returns the parameter type at the specified index, within this method type.

    Parameters
    i the index of the parameter
    num Int: the index (zero-based) of the desired parameter type
    Return
    Class<*>! the selected parameter type
    Exceptions
    java.lang.IndexOutOfBoundsException if num is not a valid index into parameterArray()

    returnType

    Added in API level 26
    fun returnType(): Class<*>!

    Returns the return type of this method type.

    Return
    Class<*>! the return type

    toMethodDescriptorString

    Added in API level 26
    fun toMethodDescriptorString(): String!

    Produces a bytecode descriptor representation of the method type.

    Note that this is not a strict inverse of fromMethodDescriptorString. Two distinct classes which share a common name but have different class loaders will appear identical when viewed within descriptor strings.

    This method is included for the benefit of applications that must generate bytecodes that process method handles and invokedynamic. fromMethodDescriptorString, because the latter requires a suitable class loader argument.

    Return
    String! the bytecode type descriptor representation

    toString

    Added in API level 26
    fun toString(): String

    Returns a string representation of the method type, of the form "(PT0,PT1...)RT". The string representation of a method type is a parenthesis enclosed, comma separated list of type names, followed immediately by the return type.

    Each type is represented by its simple name.

    Return
    String a string representation of the object.

    unwrap

    Added in API level 26
    fun unwrap(): MethodType!

    Converts all wrapper types to their corresponding primitive types. Convenience method for methodType. All primitive types (including void) will remain unchanged. A return type of java.lang.Void is changed to void.

    Return
    MethodType! a version of the original type with all wrapper types replaced

    wrap

    Added in API level 26
    fun wrap(): MethodType!

    Converts all primitive types to their corresponding wrapper types. Convenience method for methodType. All reference types (including wrapper types) will remain unchanged. A void return type is changed to the type java.lang.Void. The expression type.wrap().erase() produces the same value as type.generic().

    Return
    MethodType! a version of the original type with all primitive types replaced