如果有人试图传递一个函数，该函数使用一组参数来定义其行为，但使用另一组参数来执行，就像Scheme的:

(define (function scalar1 scalar2)
  (lambda (x) (* x scalar1 scalar2)))

参见Java中参数定义行为的传递函数

如果你只有一个不同的行，你可以添加一个参数，比如一个标志和一个If (flag)语句，它调用一行或另一行。

对于每个“函数指针”，我会创建一个小的函子类来实现你的计算。 定义一个所有类都将实现的接口，并将这些对象的实例传递到更大的函数中。这是“命令模式”和“战略模式”的结合。

@sblundy的例子很好。

你可能也会对Java 7中涉及闭包的工作感兴趣:

Java闭包的当前状态是什么?

http://gafter.blogspot.com/2006/08/closures-for-java.html http://tech.puredanger.com/java7/#closures

没有一个Java 8的答案给出了一个完整的、内聚的例子，所以它就来了。

声明接受“函数指针”的方法如下:

void doCalculation(Function<Integer, String> calculation, int parameter) {
    final String result = calculation.apply(parameter);
}

通过为函数提供lambda表达式来调用它:

doCalculation((i) -> i.toString(), 2);

@sblundy的回答很好，但匿名内部类有两个小缺陷，主要是它们往往不可重用，其次是庞大的语法。

好处是他的模式扩展到完整的类，而不需要对主类(执行计算的类)进行任何更改。

当你实例化一个新类时，你可以将参数传递到这个类中，这些参数可以作为等式中的常量——所以如果你的一个内部类看起来像这样:

f(x,y)=x*y

但有时你需要的是:

f(x,y)=x*y*2

也许第三个原因是:

f(x,y)=x*y/2

而不是创建两个匿名的内部类或添加一个“传递”参数，你可以创建一个实例化为:

InnerFunc f=new InnerFunc(1.0);// for the first
calculateUsing(f);
f=new InnerFunc(2.0);// for the second
calculateUsing(f);
f=new InnerFunc(0.5);// for the third
calculateUsing(f);

它将简单地将常量存储在类中，并在接口中指定的方法中使用它。

事实上，如果知道你的函数不会被存储/重用，你可以这样做:

InnerFunc f=new InnerFunc(1.0);// for the first
calculateUsing(f);
f.setConstant(2.0);
calculateUsing(f);
f.setConstant(0.5);
calculateUsing(f);

但是不可变的类更安全——我找不到一个理由让这样的类成为可变的。

我之所以发布这篇文章，是因为每当我听到匿名的内部类时，我就会感到畏缩——我看到过很多“必需”的冗余代码，因为程序员做的第一件事就是在他应该使用实际类的时候使用匿名，并且从来没有重新考虑过他的决定。