Package Summary Overview Summary

### class:ConstantCallSite [NONE]
    public class ConstantCallSite
    extends CallSite
A `ConstantCallSite` is a `CallSite` whose target is permanent, and can never be changed. An `invokedynamic` instruction linked to a `ConstantCallSite` is permanently bound to the call site's target. Since: 1.7

### constructor:ConstantCallSite(java.lang.invoke.MethodHandle) [NONE]
### ConstantCallSite public ConstantCallSite?(MethodHandle target) Creates a call site with a permanent target. Parameters: `target` - the target to be permanently associated with this call site Throws: `NullPointerException` - if the proposed target is null

### constructor:ConstantCallSite(java.lang.invoke.MethodType,java.lang.invoke.MethodHandle) [NONE]
### ConstantCallSite protected ConstantCallSite?(MethodType targetType, MethodHandle createTargetHook) throws Throwable Creates a call site with a permanent target, possibly bound to the call site itself. During construction of the call site, the `createTargetHook` is invoked to produce the actual target, as if by a call of the form `(MethodHandle) createTargetHook.invoke(this)` . Note that user code cannot perform such an action directly in a subclass constructor, since the target must be fixed before the `ConstantCallSite` constructor returns. The hook is said to bind the call site to a target method handle, and a typical action would be `someTarget.bindTo(this)`. However, the hook is free to take any action whatever, including ignoring the call site and returning a constant target. The result returned by the hook must be a method handle of exactly the same type as the call site. While the hook is being called, the new `ConstantCallSite` object is in a partially constructed state. In this state, a call to `getTarget`, or any other attempt to use the target, will result in an `IllegalStateException`. It is legal at all times to obtain the call site's type using the `type` method. Parameters: `targetType` - the type of the method handle to be permanently associated with this call site `createTargetHook` - a method handle to invoke (on the call site) to produce the call site's target Throws: `WrongMethodTypeException` - if the hook cannot be invoked on the required arguments, or if the target returned by the hook is not of the given `targetType` `NullPointerException` - if the hook returns a null value `ClassCastException` - if the hook returns something other than a `MethodHandle` `Throwable` - anything else thrown by the hook function

### method:getTarget() [NONE]
### getTarget public final MethodHandle getTarget() Returns the target method of the call site, which behaves like a `final` field of the `ConstantCallSite`. That is, the target is always the original value passed to the constructor call which created this instance. Specified by: `getTarget` in class `CallSite` Returns: the immutable linkage state of this call site, a constant method handle Throws: `IllegalStateException` - if the `ConstantCallSite` constructor has not completed See Also: `ConstantCallSite`, `VolatileCallSite`, `CallSite.setTarget(java.lang.invoke.MethodHandle)`, `getTarget()`, `MutableCallSite.getTarget()`, `VolatileCallSite.getTarget()`

### method:setTarget(java.lang.invoke.MethodHandle) [NONE]
### setTarget public final void setTarget?(MethodHandle ignore) Always throws an `UnsupportedOperationException`. This kind of call site cannot change its target. Specified by: `setTarget` in class `CallSite` Parameters: `ignore` - a new target proposed for the call site, which is ignored Throws: `UnsupportedOperationException` - because this kind of call site cannot change its target See Also: `CallSite.getTarget()`, `setTarget(java.lang.invoke.MethodHandle)`, `MutableCallSite.setTarget(java.lang.invoke.MethodHandle)`, `VolatileCallSite.setTarget(java.lang.invoke.MethodHandle)`

### method:dynamicInvoker() [NONE]
### dynamicInvoker public final MethodHandle dynamicInvoker() Returns this call site's permanent target. Since that target will never change, this is a correct implementation of `CallSite.dynamicInvoker`. Specified by: `dynamicInvoker` in class `CallSite` Returns: the immutable linkage state of this call site, a constant method handle Throws: `IllegalStateException` - if the `ConstantCallSite` constructor has not completed