ConstantCallSite (Java SE 26 & JDK 26)
Description: declaration: module: java.base, package: java.lang.invoke, class: ConstantCallSite
Keywords: java.lang.invoke.ConstantCallSite class

# Class ConstantCallSite

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

public non-sealed 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 Summary

  Constructors
  Modifier
  Constructor
  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

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

  ### Methods declared in class CallSite

  `type`
  Modifier and Type
  Method
  Description
  `MethodType`
  `type()`
  Returns the type of this call site's target.

  ### Methods declared in class Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
  Modifier and Type
  Method
  Description
  `protected Object`
  `clone()`
  Creates and returns a copy of this object.
  `boolean`
  `equals(Object obj)`
  Indicates whether some other object is "equal to" this one.
  `protected void`
  `finalize()`
  Deprecated, for removal: This API element is subject to removal in a future version.
  Finalization is deprecated and subject to removal in a future release.
  `final Class<?>`
  `getClass()`
  Returns the runtime class of this `Object`.
  `int`
  `hashCode()`
  Returns a hash code value for this object.
  `final void`
  `notify()`
  Wakes up a single thread that is waiting on this object's monitor.
  `final void`
  `notifyAll()`
  Wakes up all threads that are waiting on this object's monitor.
  `String`
  `toString()`
  Returns a string representation of the object.
  `final void`
  `wait()`
  Causes the current thread to wait until it is awakened, typically by being notified or interrupted.
  `final void`
  `wait(long timeoutMillis)`
  Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.
  `final void`
  `wait(long timeoutMillis, int nanos)`
  Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.

- ## Constructor Details

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

  - ### 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(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(MethodHandle)`
      - `MutableCallSite.setTarget(MethodHandle)`
      - `VolatileCallSite.setTarget(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