* Here is an example of usage, creating a hybrid object/functional datum: *
* class Greeter extends JavaMethodHandle {
* private String greeting = "hello";
* public void setGreeting(String s) { greeting = s; }
* public void run() { System.out.println(greeting+", "+greetee); }
* private final String greetee;
* Greeter(String greetee) {
* super(RUN); // alternatively, super("run")
* this.greetee = greetee;
* }
* // the entry point function is computed once:
* private static final MethodHandle RUN
* = MethodHandles.lookup().findVirtual(Greeter.class, "run",
* MethodType.make(void.class));
* }
* // class Main { public static void main(String... av) { ...
* Greeter greeter = new Greeter("world");
* greeter.run(); // prints "hello, world"
* // Statically typed method handle invocation (most direct):
* MethodHandle mh = greeter;
* mh.<void>invoke(); // also prints "hello, world"
* // Dynamically typed method handle invocation:
* MethodHandles.invoke(greeter); // also prints "hello, world"
* greeter.setGreeting("howdy");
* mh.invoke(); // prints "howdy, world" (object-like mutable behavior)
* * In the example of {@code Greeter}, the method {@code run} provides the entry point. * The entry point need not be a constant value; it may be independently * computed in each call to the constructor. The entry point does not * even need to be a method on the {@code Greeter} class, though * that is the typical case. *
* The entry point may also be provided symbolically, in which case the the * {@code JavaMethodHandle} constructor performs the lookup of the entry point. * This makes it possible to use {@code JavaMethodHandle} to create an anonymous * inner class: *
* // We can also do this with symbolic names and/or inner classes:
* MethodHandles.invoke(new JavaMethodHandle("yow") {
* void yow() { System.out.println("yow, world"); }
* });
* * Here is similar lower-level code which works in terms of a bound method handle. *
* class Greeter {
* public void run() { System.out.println("hello, "+greetee); }
* private final String greetee;
* Greeter(String greetee) { this.greetee = greetee; }
* // the entry point function is computed once:
* private static final MethodHandle RUN
* = MethodHandles.findVirtual(Greeter.class, "run",
* MethodType.make(void.class));
* }
* // class Main { public static void main(String... av) { ...
* Greeter greeter = new Greeter("world");
* greeter.run(); // prints "hello, world"
* MethodHandle mh = MethodHanndles.insertArgument(Greeter.RUN, 0, greeter);
* mh.invoke(); // also prints "hello, world"
* * Here is a pure functional value expressed most concisely as an anonymous inner class: *
* // class Main { public static void main(String... av) { ...
* final String greetee = "world";
* MethodHandle greeter = new JavaMethodHandle("run") {
* private void run() { System.out.println("hello, "+greetee); }
* }
* greeter.invoke(); // prints "hello, world"
* * Here is an abstract parameterized lvalue, efficiently expressed as a subtype of MethodHandle, * and instantiated as an anonymous class. The data structure is a handle to 1-D array, * with a specialized index type (long). It is created by inner class, and uses * signature-polymorphic APIs throughout. *
* abstract class AssignableMethodHandle extends JavaMethodHandle {
* private final MethodHandle setter;
* public MethodHandle setter() { return setter; }
* public AssignableMethodHandle(String get, String set) {
* super(get);
* MethodType getType = this.type();
* MethodType setType = getType.insertParameterType(getType.parameterCount(), getType.returnType()).changeReturnType(void.class);
* this.setter = MethodHandles.publicLookup().bind(this, set, setType);
* }
* }
* // class Main { public static void main(String... av) { ...
* final Number[] stuff = { 123, 456 };
* AssignableMethodHandle stuffPtr = new AssignableMethodHandle("get", "set") {
* public Number get(long i) { return stuff[(int)i]; }
* public void set(long i, Object x) { stuff[(int)i] = x; }
* }
* int x = (Integer) stuffPtr.<Number>invoke(1L); // 456
* stuffPtr.setter().<void>invoke(0L, (Number) 789); // replaces 123 with 789
* * The method handle type of {@code this} (i.e, the fully constructed object) * will be {@code entryPoint}, minus the leading argument. * The leading argument will be bound to {@code this} on every method * handle invocation. * @param entryPoint the method handle to handle calls */ protected JavaMethodHandle(MethodHandle entryPoint) { super(entryPoint); } /** * Create a method handle whose entry point is a non-static method * visible in the exact (most specific) class of * the newly constructed object. *
* The method is specified by name and type, as if via this expression: * {@code MethodHandles.lookup().findVirtual(this.getClass(), name, type)}. * The class defining the method might be an anonymous inner class. *
* The method handle type of {@code this} (i.e, the fully constructed object) * will be the given method handle type. * A call to {@code this} will invoke the selected method. * The receiver argument will be bound to {@code this} on every method * handle invocation. *
* Rationale: * Although this constructor may seem to be a mere luxury, * it is not subsumed by the more general constructor which * takes any {@code MethodHandle} as the entry point argument. * In order to convert an entry point name to a method handle, * the self-class of the object is required (in order to do * the lookup). The self-class, in turn, is generally not * available at the time of the constructor invocation, * due to the rules of Java and the JVM verifier. * One cannot call {@code this.getClass()}, because * the value of {@code this} is inaccessible at the point * of the constructor call. (Changing this would require * change to the Java language, verifiers, and compilers.) * In particular, this constructor allows {@code JavaMethodHandle}s * to be created in combination with the anonymous inner class syntax. * @param entryPointName the name of the entry point method * @param type (optional) the desired type of the method handle */ protected JavaMethodHandle(String entryPointName, MethodType type) { super(entryPointName, type, true); } /** * Create a method handle whose entry point is a non-static method * visible in the exact (most specific) class of * the newly constructed object. *
* The method is specified only by name. * There must be exactly one method of that name visible in the object class, * either inherited or locally declared. * (That is, the method must not be overloaded.) *
* The method handle type of {@code this} (i.e, the fully constructed object) * will be the same as the type of the selected non-static method. * The receiver argument will be bound to {@code this} on every method * handle invocation. *
ISSUE: This signature wildcarding feature does not correspond to * any MethodHandles.Lookup API element. Can we eliminate it? * Alternatively, it is useful for naming non-overloaded methods. * Shall we make type arguments optional in the Lookup methods, * throwing an error in cases of ambiguity? *
* For this method's rationale, see the documentation * for {@link #JavaMethodHandle(String,MethodType)}. * @param entryPointName the name of the entry point method */ protected JavaMethodHandle(String entryPointName) { super(entryPointName, (MethodType) null, false); } }