Java 在实例参数上调用实例方法引用

在Java中，如果给定一个非静态方法引用和一个类实例，是否可以以某种方式传递您希望该类实例调用该方法的信息

伪示例：

public Object methodApply(Function<Object,Object> method, Object instance, List<Object> args) {
    return instance.method(args);
}

公共对象方法应用（函数方法、对象实例、列表参数）{ 返回instance.method（args）； }

---

在使用any类声明的对象上，不能声明调用any方法的方法，但如果使用的话。
反射方法的缺点是，如果方法/访问无效，则在运行时可能会出现异常。

使用Java 8，您可以传递任何，但只传递来实现函数接口（它只是lambda表达式的一种替代方法）。
限制是该方法引用必须与函数接口描述符一致

---

如果您真的想使用Java 8并从类型安全性中获益来实现您的需求，那么您应该利用这样一个优势，即您可以对不构成lambda一部分的变量调用方法引用。
但还要注意，函数接口接受的参数数量不是可变的。
因此，您应该重载泛型方法以接受不同数量的参数。

例如，如果要将一个参数传递给调用的方法，

methodApply（）

应该有一个

函数

参数：

public static <T, R> R methodApply(Function<T, R> function, T arg) {
  return function.apply(arg);
}

public static <T, U, R> R methodApply(BiFunction<T, U, R> function, T argOne, U argTwo) {
  return function.apply(argOne, argTwo);
}

如果需要传递更多参数，当然可以创建自己的函数接口：

TriFunction

、

QuadriFunction

，并以相同的方式重载该方法

下面是一个示例工作代码，说明了：

import java.util.ArrayList;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.Function;

public class FunctionHelper {

    public static void main(String[] args) {

      System.out.println("methodApply() with Function" + System.lineSeparator());
      // String.concat
      String oneString = "hello";
      String concatenated = methodApply(oneString::concat, " world");
      System.out.println("concatenated="+ concatenated);

      // List add/remove
      List<String> list = new ArrayList<>();
      methodApply(list::add, concatenated);
      System.out.println("after adding, list="+list);
      methodApply(list::remove, concatenated);
      System.out.println("afer removing, list="+list);

      System.out.println("---------------------------"+ System.lineSeparator());

      System.out.println("methodApply() with BiFunction" + System.lineSeparator());
      // String.substring
      oneString = "hello world";    
      System.out.println("substring=" + methodApply(oneString::substring, 0, 6));
    }

    public static <T, R> R methodApply(Function<T, R> function, T arg) {
      return function.apply(arg);
    }

    public static <T, U, R> R methodApply(BiFunction<T, U, R> function, T argOne, U argTwo) {
      return function.apply(argOne, argTwo);
    }

}

import java.util.ArrayList；
导入java.util.List；
导入java.util.function.BiFunction；
导入java.util.function.function；
公共类函数助手{
公共静态void main（字符串[]args）{
System.out.println（“带有函数“+System.lineSeparator（）”的methodApply（））；
//String.concat
String oneString=“你好”；
String concatenated=methodApply（oneString:：concat，“world”）；
System.out.println（“concatenated=“+concatenated”）；
//添加/删除列表
列表=新的ArrayList（）；
methodApply（列表：：添加，连接）；
System.out.println（“添加后，list=“+list”）；
methodApply（列表：：删除，连接）；
System.out.println（“删除后，list=“+list”）；
System.out.println（“-------------------------------”+System.lineSeparator（））；
System.out.println（“带双函数的methodApply（）+System.lineSeparator（））；
//字符串。子字符串
oneString=“你好，世界”；
System.out.println（“substring=“+methodApply（oneString:：substring，0,6））；
}
公共静态R方法应用（函数，T参数）{
返回函数。应用（arg）；
}
公共静态R方法应用（双函数函数，T argOne，U argTwo）{
返回函数.apply（argOne，argTwo）；
}
}

输出：

methodApply（）和函数

连接=你好世界

添加后，list=[hello world]

删除后，列表=[]

---

methodApply（）和双功能

子字符串=你好

---

函数

没有意义，因为它需要输入类型和输出类型。你可能在寻找反思？@JoeC接得好！编辑以修复