compact1, compact2, compact3
java.lang.invoke

## Class ConstantCallSite

- java.lang.Object
- - java.lang.invoke.CallSite
  - - java.lang.invoke.ConstantCallSite

-     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.

- - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `` | `ConstantCallSite(MethodHandle target)` Creates a call site with a permanent target.
    `protected` | `ConstantCallSite(MethodType targetType, MethodHandle createTargetHook)` Creates a call site with a permanent target, possibly bound to the call site itself.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `MethodHandle` | `dynamicInvoker()` Returns this call site's permanent target.
    `MethodHandle` | `getTarget()` Returns the target method of the call site, which behaves like a `final` field of the `ConstantCallSite`.
    `void` | `setTarget(MethodHandle ignore)` Always throws an `UnsupportedOperationException`.

    - ### Methods inherited from class java.lang.invoke.CallSite

      `type`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### 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

    - #### 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 Detail

    - #### 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()`

    - #### 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)`

    - #### 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

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2015, Oracle and/or its affiliates. All rights reserved.