xdean.jex.util.reflect

类 FunctionInterfaceUtil

java.lang.Object

xdean.jex.util.reflect.FunctionInterfaceUtil

public class FunctionInterfaceUtil
extends Object

构造器概要

构造器

构造器和说明
FunctionInterfaceUtil()

方法概要

限定符和类型	方法和说明
static <T> Method	getFunctionInterfaceMethod(Class<?> clz) Get the method from a function interface
static <T> T	methodToFunctionInterface(Method method, Object target, Class<T> functionInterfaceClass, Class<?>... explicitGenericTypes) Adapt a method to a function interface.

从类继承的方法 java.lang.Object

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

构造器详细资料

FunctionInterfaceUtil

public FunctionInterfaceUtil()

方法详细资料

getFunctionInterfaceMethod

public static <T> Method getFunctionInterfaceMethod(Class<?> clz)

Get the method from a function interface

参数:

clz -

返回:

null if the given class is not a function interface

methodToFunctionInterface

public static <T> T methodToFunctionInterface(Method method,
                                              Object target,
                                              Class<T> functionInterfaceClass,
                                              Class<?>... explicitGenericTypes)

Adapt a method to a function interface.
For example:

 
 static int increment(int i){
  return i+1;
 }
 Method m = ...
 UnaryOperator<Integer> uo = methodToFunctionInterface(m, null, UnaryOperator.class);//work
 UnaryOperator<Integer> uo = methodToFunctionInterface(m, null, UnaryOperator.class, Integer.class);//work and more safe
 UnaryOperator<Integer> uo = methodToFunctionInterface(m, null, UnaryOperator.class, String.class);//return null
 
 

Note that only indeed adapted method can be converted.
For example: Integer function(Number) can't adapt to UnaryOperator<Integer>, though any call to a UnaryOperator<Integer> can delegate by the function. Because you can't define like:

 
 interface Function extends UnaryOperator<Integer> {
   @Override
   public Integer apply(Number t);//error
 }
 
 

Now only ignored things is ParameterizedType. That means this method consider return type and parameter types as raw type.

参数:

method - The method to adapt. Ensure the method can be access.

target - The method's target. If the method is static, target should be null.

functionInterfaceClass - The function interface to adapt to.

explicitGenericTypes - If the function interface has generic type, you can specify them in order. If a explicit type is null, it will be ignored.

返回:

Instance of the function interface. Or null if can't adapt to. Note that returned object is raw type. If you don't specify explicit generic types, IllegalArgumentException(type mismatch) may happen when you call it.