Serializable
, Constable
, TypeDescriptor
, TypeDescriptor.OfMethod<Class<?>,MethodType>
public final class MethodType extends Object implements Constable, TypeDescriptor.OfMethod<Class<?>,MethodType>, Serializable
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.
A MethodType
can be described in nominal form if and only if all of the parameter types and return type can be described with a nominal descriptor
represented by ClassDesc
. If a method type can be described nominally, then:
nominal descriptor
returned by MethodType::describeConstable
.MethodType::descriptorString
or MethodType::toMethodDescriptorString
for the method type is a method descriptor (JVMS 4.3.3). If any of the parameter types or return type cannot be described nominally, i.e. Class::describeConstable
returns an empty optional for that type, then the method type cannot be described nominally:
nominal descriptor
and MethodType::describeConstable
returns an empty optional.MethodType::descriptorString
or MethodType::toMethodDescriptorString
for the method type is not a type descriptor.TypeDescriptor.OfField<F extends TypeDescriptor.OfField<F>>, TypeDescriptor.OfMethod<F extends TypeDescriptor.OfField<F>,M extends TypeDescriptor.OfMethod<F,M>>
Modifier and Type | Method | Description |
---|---|---|
MethodType |
appendParameterTypes |
Finds or creates a method type with additional parameter types. |
MethodType |
appendParameterTypes |
Finds or creates a method type with additional parameter types. |
MethodType |
changeParameterType |
Finds or creates a method type with a single different parameter type. |
MethodType |
changeReturnType |
Finds or creates a method type with a different return type. |
Optional |
describeConstable() |
Returns a nominal descriptor for this instance, if one can be constructed, or an empty Optional if one cannot be. |
String |
descriptorString() |
Returns the descriptor string for this method type. |
MethodType |
dropParameterTypes |
Finds or creates a method type with some parameter types omitted. |
boolean |
equals |
Compares the specified object with this type for equality. |
MethodType |
erase() |
Erases all reference types to Object . |
static MethodType |
fromMethodDescriptorString |
Finds or creates an instance of a method type of the given method descriptor (JVMS 4.3.3). |
MethodType |
generic() |
Converts all types, both reference and primitive, to Object . |
static MethodType |
genericMethodType |
Finds or creates a method type whose components are all Object . |
static MethodType |
genericMethodType |
Finds or creates a method type whose components are Object with an optional trailing Object[] array. |
int |
hashCode() |
Returns the hash code value for this method type. |
boolean |
hasPrimitives() |
Reports if this type contains a primitive argument or return value. |
boolean |
hasWrappers() |
Reports if this type contains a wrapper argument or return value. |
MethodType |
insertParameterTypes |
Finds or creates a method type with additional parameter types. |
MethodType |
insertParameterTypes |
Finds or creates a method type with additional parameter types. |
Class |
lastParameterType() |
Returns the last parameter type of this method type. |
static MethodType |
methodType |
Finds or creates a method type with the given components. |
static MethodType |
methodType |
Finds or creates a method type with the given components. |
static MethodType |
methodType |
Finds or creates an instance of the given method type. |
static MethodType |
methodType |
Finds or creates a method type with the given components. |
static MethodType |
methodType |
Finds or creates a method type with the given components. |
static MethodType |
methodType |
Finds or creates a method type with the given components. |
Class<?>[] |
parameterArray() |
Presents the parameter types as an array (a convenience method). |
int |
parameterCount() |
Returns the number of parameter types in this method type. |
List |
parameterList() |
Presents the parameter types as a list (a convenience method). |
Class |
parameterType |
Returns the parameter type at the specified index, within this method type. |
Class |
returnType() |
Returns the return type of this method type. |
String |
toMethodDescriptorString() |
Returns the descriptor string for this method type. |
String |
toString() |
Returns a string representation of the method type, of the form "(PT0,PT1...)RT" . |
MethodType |
unwrap() |
Converts all wrapper types to their corresponding primitive types. |
MethodType |
wrap() |
Converts all primitive types to their corresponding wrapper types. |
public static MethodType methodType(Class<?> rtype, Class<?>[] ptypes)
rtype
- the return typeptypes
- the parameter typesNullPointerException
- if rtype
or ptypes
or any element of ptypes
is nullIllegalArgumentException
- if any element of ptypes
is void.class
public static MethodType methodType(Class<?> rtype, List<Class<?>> ptypes)
methodType
.rtype
- the return typeptypes
- the parameter typesNullPointerException
- if rtype
or ptypes
or any element of ptypes
is nullIllegalArgumentException
- if any element of ptypes
is void.class
public static MethodType methodType(Class<?> rtype, Class<?> ptype0, Class<?>... ptypes)
methodType
. The leading parameter type is prepended to the remaining array.rtype
- the return typeptype0
- the first parameter typeptypes
- the remaining parameter typesNullPointerException
- if rtype
or ptype0
or ptypes
or any element of ptypes
is nullIllegalArgumentException
- if ptype0
or ptypes
or any element of ptypes
is void.class
public static MethodType methodType(Class<?> rtype)
methodType
. The resulting method has no parameter types.rtype
- the return typeNullPointerException
- if rtype
is nullpublic static MethodType methodType(Class<?> rtype, Class<?> ptype0)
methodType
. The resulting method has the single given parameter type.rtype
- the return typeptype0
- the parameter typeNullPointerException
- if rtype
or ptype0
is nullIllegalArgumentException
- if ptype0
is void.class
public static MethodType methodType(Class<?> rtype, MethodType ptypes)
methodType
. The resulting method has the same parameter types as ptypes
, and the specified return type.rtype
- the return typeptypes
- the method type which supplies the parameter typesNullPointerException
- if rtype
or ptypes
is nullpublic static MethodType genericMethodType(int objectArgCount, boolean finalArray)
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[]
.objectArgCount
- number of parameters (excluding the final array parameter if any)finalArray
- whether there will be a trailing array parameter, of type Object[]
IllegalArgumentException
- if objectArgCount
is negative or greater than 255 (or 254, if finalArray
is true)public static MethodType genericMethodType(int objectArgCount)
Object
. Convenience method for methodType
. All parameters and the return type will be Object.objectArgCount
- number of parametersIllegalArgumentException
- if objectArgCount
is negative or greater than 255public MethodType changeParameterType(int num, Class<?> nptype)
methodType
.changeParameterType
in interface TypeDescriptor.OfMethod<Class<?>,MethodType>
num
- the index (zero-based) of the parameter type to changenptype
- a new parameter type to replace the old one withIndexOutOfBoundsException
- if num
is not a valid index into parameterArray()
IllegalArgumentException
- if nptype
is void.class
NullPointerException
- if nptype
is nullpublic MethodType insertParameterTypes(int num, Class<?>... ptypesToInsert)
methodType
.insertParameterTypes
in interface TypeDescriptor.OfMethod<Class<?>,MethodType>
num
- the position (zero-based) of the inserted parameter type(s)ptypesToInsert
- zero or more new parameter types to insert into the parameter listIndexOutOfBoundsException
- if num
is negative or greater than parameterCount()
IllegalArgumentException
- if any element of ptypesToInsert
is void.class
or if the resulting method type would have more than 255 parameter slotsNullPointerException
- if ptypesToInsert
or any of its elements is nullpublic MethodType appendParameterTypes(Class<?>... ptypesToInsert)
methodType
.ptypesToInsert
- zero or more new parameter types to insert after the end of the parameter listIllegalArgumentException
- if any element of ptypesToInsert
is void.class
or if the resulting method type would have more than 255 parameter slotsNullPointerException
- if ptypesToInsert
or any of its elements is nullpublic MethodType insertParameterTypes(int num, List<Class<?>> ptypesToInsert)
methodType
.num
- the position (zero-based) of the inserted parameter type(s)ptypesToInsert
- zero or more new parameter types to insert into the parameter listIndexOutOfBoundsException
- if num
is negative or greater than parameterCount()
IllegalArgumentException
- if any element of ptypesToInsert
is void.class
or if the resulting method type would have more than 255 parameter slotsNullPointerException
- if ptypesToInsert
or any of its elements is nullpublic MethodType appendParameterTypes(List<Class<?>> ptypesToInsert)
methodType
.ptypesToInsert
- zero or more new parameter types to insert after the end of the parameter listIllegalArgumentException
- if any element of ptypesToInsert
is void.class
or if the resulting method type would have more than 255 parameter slotsNullPointerException
- if ptypesToInsert
or any of its elements is nullpublic MethodType dropParameterTypes(int start, int end)
methodType
.dropParameterTypes
in interface TypeDescriptor.OfMethod<Class<?>,MethodType>
start
- the index (zero-based) of the first parameter type to removeend
- the index (greater than start
) of the first parameter type after not to removeIndexOutOfBoundsException
- if start
is negative or greater than parameterCount()
or if end
is negative or greater than parameterCount()
or if start
is greater than end
public MethodType changeReturnType(Class<?> nrtype)
methodType
.changeReturnType
in interface TypeDescriptor.OfMethod<Class<?>,MethodType>
nrtype
- a return parameter type to replace the old one withNullPointerException
- if nrtype
is nullpublic boolean hasPrimitives()
void
counts as a primitive.public boolean hasWrappers()
Integer
. The reference type java.lang.Void
counts as a wrapper, if it occurs as a return type.public MethodType erase()
Object
. Convenience method for methodType
. All primitive types (including void
) will remain unchanged.public MethodType generic()
Object
. Convenience method for genericMethodType
. The expression type.wrap().erase()
produces the same value as type.generic()
.public MethodType wrap()
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()
.public MethodType unwrap()
methodType
. All primitive types (including void
) will remain unchanged. A return type of java.lang.Void
is changed to void
.public Class<?> parameterType(int num)
parameterType
in interface TypeDescriptor.OfMethod<Class<?>,MethodType>
num
- the index (zero-based) of the desired parameter typeIndexOutOfBoundsException
- if num
is not a valid index into parameterArray()
public int parameterCount()
parameterCount
in interface TypeDescriptor.OfMethod<Class<?>,MethodType>
public Class<?> returnType()
returnType
in interface TypeDescriptor.OfMethod<Class<?>,MethodType>
public List<Class<?>> parameterList()
parameterList
in interface TypeDescriptor.OfMethod<Class<?>,MethodType>
public Class<?> lastParameterType()
void.class
is returned instead. The sentinel value is chosen so that reflective queries can be made directly against the result value. The sentinel value cannot be confused with a real parameter, since void
is never acceptable as a parameter type. For variable arity invocation modes, the expression lastParameterType().getComponentType()
is useful to query the type of the "varargs" parameter.
void.class
public Class<?>[] parameterArray()
parameterArray
in interface TypeDescriptor.OfMethod<Class<?>,MethodType>
public boolean equals(Object x)
true
if and only if the specified object is also a method type with exactly the same parameters and return type.public int hashCode()
public String toString()
"(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
.
public static MethodType fromMethodDescriptorString(String descriptor, ClassLoader loader) throws IllegalArgumentException, TypeNotPresentException
methodType
. Any class or interface name embedded in the descriptor string will be resolved by the given loader (or if it is null
, on the system class loader). This method is included for the benefit of applications that must generate bytecodes that process method handles and invokedynamic
.
descriptor
- a method descriptor stringloader
- the class loader in which to look up the typesNullPointerException
- if the string is null
IllegalArgumentException
- if the string is not a method descriptorTypeNotPresentException
- if a named type cannot be foundSecurityException
- if the security manager is present and loader
is null
and the caller does not have the RuntimePermission
("getClassLoader")
public String toMethodDescriptorString()
MethodType::descriptorString
.fromMethodDescriptorString
which requires a method type descriptor (JVMS 4.3.3) and a suitable class loader argument. Two distinct MethodType
objects can have an identical descriptor string as distinct classes can have the same name but different class loaders. This method is included for the benefit of applications that must generate bytecodes that process method handles and invokedynamic
.
public String descriptorString()
If this method type can be described nominally, then the result is a method type descriptor (JVMS 4.3.3). MethodTypeDesc
for this method type can be produced by calling MethodTypeDesc::ofDescriptor
with the result descriptor string.
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. No MethodTypeDesc
can be produced from the result string.descriptorString
in interface TypeDescriptor
public Optional<MethodTypeDesc> describeConstable()
Optional
if one cannot be.describeConstable
in interface Constable
Optional
containing the resulting nominal descriptor, or an empty Optional
if one cannot be constructed.
© 1993, 2023, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/invoke/MethodType.html