{@code FT f;} * </tr> * <tr> * <td>{@code 3} * <td>{@code FT f;} * </tr> * <tr> * <td>{@code 4} * <td>{@code static}
{@code FT f;} * </tr> * <tr> * <td>{@code 5} * <td>{@code T m(A*);} * </tr> * <tr> * <td>{@code 6} * <td>{@code static}
{@code T m(A*);} * </tr> * <tr> * <td>{@code 7} * <td>{@code T m(A*);} * </tr> * <tr> * <td>{@code 8} * <td>{@code C(A*);} * </tr> * <tr> * <td>{@code 9} * <td>{@code T m(A*);} * </tr> * </table> * @since 1.8 */ public interface MethodHandleInfo { /** * A direct method handle reference kind, * as defined in the <a href="MethodHandleInfo.html#refkinds">table above. */ public static final int REF_getField = Constants.REF_getField, REF_getStatic = Constants.REF_getStatic, REF_putField = Constants.REF_putField, REF_putStatic = Constants.REF_putStatic, REF_invokeVirtual = Constants.REF_invokeVirtual, REF_invokeStatic = Constants.REF_invokeStatic, REF_invokeSpecial = Constants.REF_invokeSpecial, REF_newInvokeSpecial = Constants.REF_newInvokeSpecial, REF_invokeInterface = Constants.REF_invokeInterface; /** * Returns the reference kind of the cracked method handle, which in turn * determines whether the method handle's underlying member was a constructor, method, or field. * See the <a href="MethodHandleInfo.html#refkinds">table above for definitions. * @return the integer code for the kind of reference used to access the underlying member */ public int getReferenceKind(); /** * Returns the class in which the cracked method handle's underlying member was defined. * @return the declaring class of the underlying member */ public Class<?> getDeclaringClass(); /** * Returns the name of the cracked method handle's underlying member. * This is {@code "<init>"} if the underlying member was a constructor, * else it is a simple method name or field name. * @return the simple name of the underlying member */ public String getName(); /** * Returns the nominal type of the cracked symbolic reference, expressed as a method type. * If the reference is to a constructor, the return type will be {@code void}. * If it is to a non-static method, the method type will not mention the {@code this} parameter. * If it is to a field and the requested access is to read the field, * the method type will have no parameters and return the field type. * If it is to a field and the requested access is to write the field, * the method type will have one parameter of the field type and return {@code void}. * <p> * Note that original direct method handle may include a leading {@code this} parameter, * or (in the case of a constructor) will replace the {@code void} return type * with the constructed class. * The nominal type does not include any {@code this} parameter, * and (in the case of a constructor) will return {@code void}. * @return the type of the underlying member, expressed as a method type */ public MethodType getMethodType(); // Utility methods. // NOTE: class/name/type and reference kind constitute a symbolic reference // member and modifiers are an add-on, derived from Core Reflection (or the equivalent) /** * Reflects the underlying member as a method, constructor, or field object. * If the underlying member is public, it is reflected as if by * {@code getMethod}, {@code getConstructor}, or {@code getField}. * Otherwise, it is reflected as if by * {@code getDeclaredMethod}, {@code getDeclaredConstructor}, or {@code getDeclaredField}. * The underlying member must be accessible to the given lookup object. * @param <T> the desired type of the result, either {@link Member} or a subtype * @param expected a class object representing the desired result type {@code T} * @param lookup the lookup object that created this MethodHandleInfo, or one with equivalent access privileges * @return a reference to the method, constructor, or field object * @exception ClassCastException if the member is not of the expected type * @exception NullPointerException if either argument is {@code null} * @exception IllegalArgumentException if the underlying member is not accessible to the given lookup object */ public <T extends Member> T reflectAs(Class
Other Java examples (source code examples)
Here is a short list of links related to this Java MethodHandleInfo.java source code file:
The search page
Other Java source code examples at this package level
Click here to learn more about this project
Java example source code file (MethodHandleInfo.java)
The MethodHandleInfo.java Java example source code/*
* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.lang.invoke;
import java.lang.reflect.*;
import java.util.*;
import java.lang.invoke.MethodHandleNatives.Constants;
import java.lang.invoke.MethodHandles.Lookup;
import static java.lang.invoke.MethodHandleStatics.*;
/**
* A symbolic reference obtained by cracking a direct method handle
* into its consitutent symbolic parts.
* To crack a direct method handle, call {@link Lookup#revealDirect Lookup.revealDirect}.
* <h1>Direct Method Handles
* A <em>direct method handle represents a method, constructor, or field without
* any intervening argument bindings or other transformations.
* The method, constructor, or field referred to by a direct method handle is called
* its <em>underlying member.
* Direct method handles may be obtained in any of these ways:
* <ul>
* <li>By executing an {@code ldc} instruction on a {@code CONSTANT_MethodHandle} constant.
* (See the Java Virtual Machine Specification, sections 4.4.8 and 5.4.3.)
* <li>By calling one of the Lookup Factory Methods,
* such as {@link Lookup#findVirtual Lookup.findVirtual},
* to resolve a symbolic reference into a method handle.
* A symbolic reference consists of a class, name string, and type.
* <li>By calling the factory method {@link Lookup#unreflect Lookup.unreflect}
* or {@link Lookup#unreflectSpecial Lookup.unreflectSpecial}
* to convert a {@link Method} into a method handle.
* <li>By calling the factory method {@link Lookup#unreflectConstructor Lookup.unreflectConstructor}
* to convert a {@link Constructor} into a method handle.
* <li>By calling the factory method {@link Lookup#unreflectGetter Lookup.unreflectGetter}
* or {@link Lookup#unreflectSetter Lookup.unreflectSetter}
* to convert a {@link Field} into a method handle.
* </ul>
*
* <h1>Restrictions on Cracking
* Given a suitable {@code Lookup} object, it is possible to crack any direct method handle
* to recover a symbolic reference for the underlying method, constructor, or field.
* Cracking must be done via a {@code Lookup} object equivalent to that which created
* the target method handle, or which has enough access permissions to recreate
* an equivalent method handle.
* <p>
* If the underlying method is <a href="MethodHandles.Lookup.html#callsens">caller sensitive,
* the direct method handle will have been "bound" to a particular caller class, the
* {@linkplain java.lang.invoke.MethodHandles.Lookup#lookupClass() lookup class}
* of the lookup object used to create it.
* Cracking this method handle with a different lookup class will fail
* even if the underlying method is public (like {@code Class.forName}).
* <p>
* The requirement of lookup object matching provides a "fast fail" behavior
* for programs which may otherwise trust erroneous revelation of a method
* handle with symbolic information (or caller binding) from an unexpected scope.
* Use {@link java.lang.invoke.MethodHandles#reflectAs} to override this limitation.
*
* <h1>Reference kinds
* The <a href="MethodHandles.Lookup.html#lookups">Lookup Factory Methods
* correspond to all major use cases for methods, constructors, and fields.
* These use cases may be distinguished using small integers as follows:
* <table border=1 cellpadding=5 summary="reference kinds">
* <tr> | reference kind | descriptive name | scope | member | behavior | |||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| {@code REF_getField} | {@code class} | {@code (T) this.f;} | {@code REF_getStatic} | {@code class} or {@code interface} | {@code (T) C.f;} | {@code REF_putField} | {@code class} | {@code this.f = x;} | {@code REF_putStatic} | {@code class} | {@code C.f = arg;} | {@code REF_invokeVirtual} | {@code class} | {@code (T) this.m(arg*);} | {@code REF_invokeStatic} | {@code class} or {@code interface} | {@code (T) C.m(arg*);} | {@code REF_invokeSpecial} | {@code class} or {@code interface} | {@code (T) super.m(arg*);} | {@code REF_newInvokeSpecial} | {@code class} | {@code new C(arg*);} | {@code REF_invokeInterface} | {@code interface} | {@code (T) this.m(arg*);} |
