Package Summary Overview Summary

### class:ConstantBootstraps [NONE]
    public final class ConstantBootstraps
    extends Object
Bootstrap methods for dynamically-computed constants. The bootstrap methods in this class will throw a `NullPointerException` for any reference argument that is `null`, unless the argument is specified to be unused or specified to accept a `null` value. Since: 11

### method:nullConstant(java.lang.invoke.MethodHandles.Lookup,java.lang.String,java.lang.Class) [NONE]
### nullConstant public static Object nullConstant?(MethodHandles.Lookup lookup, String name, Class<?> type) Returns a `null` object reference for the reference type specified by `type`. Parameters: `lookup` - unused `name` - unused `type` - a reference type Returns: a `null` value Throws: `IllegalArgumentException` - if `type` is not a reference type

### method:primitiveClass(java.lang.invoke.MethodHandles.Lookup,java.lang.String,java.lang.Class) [NONE]
### primitiveClass public static Class<?> primitiveClass?(MethodHandles.Lookup lookup, String name, Class<?> type) Returns a `Class` mirror for the primitive type whose type descriptor is specified by `name`. Parameters: `lookup` - unused `name` - the descriptor (JVMS 4.3) of the desired primitive type `type` - the required result type (must be `Class.class`) Returns: the `Class` mirror Throws: `IllegalArgumentException` - if the name is not a descriptor for a primitive type or the type is not `Class.class`

### method:enumConstant(java.lang.invoke.MethodHandles.Lookup,java.lang.String,java.lang.Class) [NONE]
### enumConstant public static <E extends Enum<E>> E enumConstant?(MethodHandles.Lookup lookup, String name, Class<E> type) Returns an `enum` constant of the type specified by `type` with the name specified by `name`. Type Parameters: `E` - The enum type for which a constant value is to be returned Parameters: `lookup` - the lookup context describing the class performing the operation (normally stacked by the JVM) `name` - the name of the constant to return, which must exactly match an enum constant in the specified type. `type` - the `Class` object describing the enum type for which a constant is to be returned Returns: the enum constant of the specified enum type with the specified name Throws: `IllegalAccessError` - if the declaring class or the field is not accessible to the class performing the operation `IllegalArgumentException` - if the specified enum type has no constant with the specified name, or the specified class object does not represent an enum type See Also: `Enum.valueOf(Class, String)`

### method:getStaticFinal(java.lang.invoke.MethodHandles.Lookup,java.lang.String,java.lang.Class,java.lang.Class) [NONE]
### getStaticFinal public static Object getStaticFinal?(MethodHandles.Lookup lookup, String name, Class<?> type, Class<?> declaringClass) Returns the value of a static final field. Parameters: `lookup` - the lookup context describing the class performing the operation (normally stacked by the JVM) `name` - the name of the field `type` - the type of the field `declaringClass` - the class in which the field is declared Returns: the value of the field Throws: `IllegalAccessError` - if the declaring class or the field is not accessible to the class performing the operation `NoSuchFieldError` - if the specified field does not exist `IncompatibleClassChangeError` - if the specified field is not `final`

### method:getStaticFinal(java.lang.invoke.MethodHandles.Lookup,java.lang.String,java.lang.Class) [NONE]
### getStaticFinal public static Object getStaticFinal?(MethodHandles.Lookup lookup, String name, Class<?> type) Returns the value of a static final field declared in the class which is the same as the field's type (or, for primitive-valued fields, declared in the wrapper class.) This is a simplified form of `getStaticFinal(MethodHandles.Lookup, String, Class, Class)` for the case where a class declares distinguished constant instances of itself. Parameters: `lookup` - the lookup context describing the class performing the operation (normally stacked by the JVM) `name` - the name of the field `type` - the type of the field Returns: the value of the field Throws: `IllegalAccessError` - if the declaring class or the field is not accessible to the class performing the operation `NoSuchFieldError` - if the specified field does not exist `IncompatibleClassChangeError` - if the specified field is not `final` See Also: `getStaticFinal(MethodHandles.Lookup, String, Class, Class)`

### method:invoke(java.lang.invoke.MethodHandles.Lookup,java.lang.String,java.lang.Class,java.lang.invoke.MethodHandle,java.lang.Object...) [NONE]
### invoke public static Object invoke?(MethodHandles.Lookup lookup, String name, Class<?> type, MethodHandle handle, Object... args) throws Throwable Returns the result of invoking a method handle with the provided arguments. This method behaves as if the method handle to be invoked is the result of adapting the given method handle, via `MethodHandle.asType(java.lang.invoke.MethodType)`, to adjust the return type to the desired type. Parameters: `lookup` - unused `name` - unused `type` - the desired type of the value to be returned, which must be compatible with the return type of the method handle `handle` - the method handle to be invoked `args` - the arguments to pass to the method handle, as if with `MethodHandle.invokeWithArguments(java.lang.Object...)`. Each argument may be `null`. Returns: the result of invoking the method handle Throws: `WrongMethodTypeException` - if the handle's method type cannot be adjusted to take the given number of arguments, or if the handle's return type cannot be adjusted to the desired type `ClassCastException` - if an argument or the result produced by invoking the handle cannot be converted by reference casting `Throwable` - anything thrown by the method handle invocation

### method:fieldVarHandle(java.lang.invoke.MethodHandles.Lookup,java.lang.String,java.lang.Class,java.lang.Class,java.lang.Class) [NONE]
### fieldVarHandle public static VarHandle fieldVarHandle?(MethodHandles.Lookup lookup, String name, Class<VarHandle> type, Class<?> declaringClass, Class<?> fieldType) Finds a `VarHandle` for an instance field. Parameters: `lookup` - the lookup context describing the class performing the operation (normally stacked by the JVM) `name` - the name of the field `type` - the required result type (must be `Class<VarHandle>`) `declaringClass` - the class in which the field is declared `fieldType` - the type of the field Returns: the `VarHandle` Throws: `IllegalAccessError` - if the declaring class or the field is not accessible to the class performing the operation `NoSuchFieldError` - if the specified field does not exist `IllegalArgumentException` - if the type is not `VarHandle`

### method:staticFieldVarHandle(java.lang.invoke.MethodHandles.Lookup,java.lang.String,java.lang.Class,java.lang.Class,java.lang.Class) [NONE]
### staticFieldVarHandle public static VarHandle staticFieldVarHandle?(MethodHandles.Lookup lookup, String name, Class<VarHandle> type, Class<?> declaringClass, Class<?> fieldType) Finds a `VarHandle` for a static field. Parameters: `lookup` - the lookup context describing the class performing the operation (normally stacked by the JVM) `name` - the name of the field `type` - the required result type (must be `Class<VarHandle>`) `declaringClass` - the class in which the field is declared `fieldType` - the type of the field Returns: the `VarHandle` Throws: `IllegalAccessError` - if the declaring class or the field is not accessible to the class performing the operation `NoSuchFieldError` - if the specified field does not exist `IllegalArgumentException` - if the type is not `VarHandle`

### method:arrayVarHandle(java.lang.invoke.MethodHandles.Lookup,java.lang.String,java.lang.Class,java.lang.Class) [NONE]
### arrayVarHandle public static VarHandle arrayVarHandle?(MethodHandles.Lookup lookup, String name, Class<VarHandle> type, Class<?> arrayClass) Finds a `VarHandle` for an array type. Parameters: `lookup` - the lookup context describing the class performing the operation (normally stacked by the JVM) `name` - unused `type` - the required result type (must be `Class<VarHandle>`) `arrayClass` - the type of the array Returns: the `VarHandle` Throws: `IllegalAccessError` - if the component type of the array is not accessible to the class performing the operation `IllegalArgumentException` - if the type is not `VarHandle`