如何在Java中将函数作为参数传递？ [重复]

Question

这个问题在这里已经有了答案：

Java 传递方法作为参数（16 个回答）

7年前关闭。

在 Java 中，如何将一个函数作为另一个函数的参数传递？

Answer 1

Java 8 及以上

使用 Java 8+ lambda 表达式，如果您的类或接口只有一个抽象方法（有时称为SAM 类型），例如：

public interface MyInterface {
    String doSomething(int param1, String param2);
}

然后在使用 MyInterface 的任何地方，您都可以替换 lambda 表达式：

class MyClass {
    public MyInterface myInterface = (p1, p2) -> { return p2 + p1; };
}

例如，您可以非常快速地创建一个新线程：

new Thread(() -> someMethod()).start();

并使用方法引用语法使其更清晰：

new Thread(this::someMethod).start();

如果没有lambda 表达式，最后两个示例将如下所示：

new Thread(new Runnable() { someMethod(); }).start();

在 Java 8 之前

一个常见的模式是将它“包装”在一个接口中，例如Callable ，然后你传入一个 Callable ：

public T myMethod(Callable<T> func) {
    return func.call();
}

这种模式被称为命令模式。

请记住，您最好为您的特定用途创建一个界面。 如果您选择使用 callable，那么您可以将上面的 T 替换为您期望的任何类型的返回值，例如 String。

在回复您下面的评论时，您可以说：

public int methodToPass() { 
        // do something
}

public void dansMethod(int i, Callable<Integer> myFunc) {
       // do something
}

然后调用它，也许使用匿名内部类：

dansMethod(100, new Callable<Integer>() {
   public Integer call() {
        return methodToPass();
   }
});

请记住，这不是“技巧”。 它只是 java 中与函数指针等价的基本概念。

Answer 2

您可以使用 Java 反射来执行此操作。 该方法将表示为java.lang.reflect.Method 的一个实例。

import java.lang.reflect.Method;

public class Demo {

    public static void main(String[] args) throws Exception{
        Class[] parameterTypes = new Class[1];
        parameterTypes[0] = String.class;
        Method method1 = Demo.class.getMethod("method1", parameterTypes);

        Demo demo = new Demo();
        demo.method2(demo, method1, "Hello World");
    }

    public void method1(String message) {
        System.out.println(message);
    }

    public void method2(Object object, Method method, String message) throws Exception {
        Object[] parameters = new Object[1];
        parameters[0] = message;
        method.invoke(object, parameters);
    }

}

Answer 3

Lambda 表达式

要添加到jk. 的优秀答案中，您现在可以使用Lambda 表达式（在 Java 8 中）更轻松地传递方法。 首先，一些背景。 函数式接口是一个只有一个抽象方法的接口，尽管它可以包含任意数量的默认方法（Java 8 中的新方法）和静态方法。 lambda 表达式可以快速实现抽象方法，如果不使用 lambda 表达式，则不需要所有不必要的语法。

没有 lambda 表达式：

obj.aMethod(new AFunctionalInterface() {
    @Override
    public boolean anotherMethod(int i)
    {
        return i == 982
    }
});

使用 lambda 表达式：

obj.aMethod(i -> i == 982);

---

以下是关于 Lambda 表达式的 Java 教程的摘录：

Lambda 表达式的语法

一个 lambda 表达式包含以下内容：

• 括号中以逗号分隔的形式参数列表。 CheckPerson.test 方法包含一个参数 p，它表示 Person 类的一个实例。
  
  注意：您可以省略 lambda 表达式中参数的数据类型。 另外，如果只有一个参数，可以省略括号。 例如，以下 lambda 表达式也是有效的：

   p -> p.getGender() == Person.Sex.MALE && p.getAge() >= 18 && p.getAge() <= 25

• 箭头标记， ->

• 主体，由单个表达式或语句块组成。 此示例使用以下表达式：

   p.getGender() == Person.Sex.MALE && p.getAge() >= 18 && p.getAge() <= 25

  如果指定单个表达式，则 Java 运行时会计算该表达式，然后返回其值。 或者，您可以使用 return 语句：

   p -> { return p.getGender() == Person.Sex.MALE && p.getAge() >= 18 && p.getAge() <= 25; }

  return 语句不是表达式； 在 lambda 表达式中，您必须将语句括在大括号 ({}) 中。 但是，您不必将 void 方法调用括在大括号中。 例如，以下是一个有效的 lambda 表达式：

   email -> System.out.println(email)

请注意，一个 lambda 表达式看起来很像一个方法声明； 您可以将 lambda 表达式视为匿名方法——没有名称的方法。

---

以下是使用 lambda 表达式“传递方法”的方法：

^{注意：这使用了一个新的标准功能接口java.util.function.IntConsumer 。}

class A {
    public static void methodToPass(int i) { 
        // do stuff
    }
}

import java.util.function.IntConsumer;

class B {
    public void dansMethod(int i, IntConsumer aMethod) {
        /* you can now call the passed method by saying aMethod.accept(i), and it
        will be the equivalent of saying A.methodToPass(i) */
    }
}

class C {
    B b = new B();

    public C() {
        b.dansMethod(100, j -> A.methodToPass(j));   //Lambda Expression here
    }
}

---

使用::运算符可以进一步缩短上面的示例。

public C() {
    b.dansMethod(100, A::methodToPass);
}

Answer 4

感谢 Java 8，您无需执行以下步骤即可将函数传递给方法，这就是 lambdas 的用途，请参阅Oracle 的 Lambda 表达式教程。 这篇文章的其余部分描述了我们过去为了实现这个功能而不得不做的事情。

通常，您将方法声明为使用单个方法接受某个接口，然后传入一个实现该接口的对象。 一个例子是在 commons-collections 中，你有闭包、变换器和谓词的接口，以及你传递这些实现的方法。 Guava 是新改进的 commons-collections，你可以在那里找到等效的接口。

因此，例如，commons-collections 有 org.apache.commons.collections.CollectionUtils，它有许多静态方法，这些方法接受传入的对象，随机选择一个，有一个名为exists，具有此签名：

static boolean exists(java.util.Collection collection, Predicate predicate) 

它需要一个实现接口 Predicate 的对象，这意味着它必须有一个方法来获取一些 Object 并返回一个布尔值。

所以我可以这样称呼它：

CollectionUtils.exists(someCollection, new Predicate() {
    public boolean evaluate(Object object) { 
        return ("a".equals(object.toString());
    }
});

它返回真或假取决于someCollection是否包含谓词为其返回真的对象。

无论如何，这只是一个例子，commons-collections 已经过时了。 我只是忘记了番石榴中的等价物。

Answer 5

Java 支持闭包就好了。 它只是不支持functions ，所以你习惯的闭包语法更加笨拙和笨重：你必须用一个方法把所有东西都包装在一个类中。 例如，

public Runnable foo(final int x) {
  return new Runnable() {
    public void run() {
      System.out.println(x);
    }
  };
}

将返回一个 Runnable 对象，其run()方法“关闭”传入的x ，就像在任何支持一流函数和闭包的语言中一样。

Answer 6

我使用了@jk 的命令模式。 提到，添加一个返回类型：

public interface Callable<I, O> {

    public O call(I input);   
}

Answer 7

我知道这是一个相当老的帖子，但我有另一个稍微简单的解决方案。 您可以在其中创建另一个类并使其抽象。 接下来创建一个抽象方法，随意命名。 在原类中创建一个以新类为参数的方法，在这个方法中调用抽象方法。 它看起来像这样。

public class Demo {

    public Demo(/.../){

    }

    public void view(Action a){
        a.preform();
    }

    /**
     * The Action Class is for making the Demo
     * View Custom Code
     */
    public abstract class Action {

        public Action(/.../){

        }

        abstract void preform();
    }
}

现在你可以做这样的事情来从类中调用一个方法。

/...
Demo d = new Demo;
Action a = new Action() {

    @Override
    void preform() {
        //Custom Method Code Goes Here
    }
};

/.../
d.view(a)

就像我说的，我知道它是旧的，但我认为这样更容易一些。 希望它有帮助。

Answer 8

Java（尚）不支持闭包。 但是还有其他语言，如Scala和 Groovy，它们在 JVM 中运行并支持闭包。