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

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

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

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

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

匿名内部类

假设你想要传入一个带有String参数的函数，该参数返回一个整型。 首先，如果不能重用现有的接口，则必须定义一个接口，该接口的唯一成员是该函数。

interface StringFunction {
    int func(String param);
}

接受指针的方法只接受StringFunction实例，如下所示:

public void takingMethod(StringFunction sf) {
   int i = sf.func("my string");
   // do whatever ...
}

并且会被这样称呼:

ref.takingMethod(new StringFunction() {
    public int func(String param) {
        // body
    }
});

编辑:在Java 8中，你可以用lambda表达式调用它:

ref.takingMethod(param -> bodyExpression);

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

@sblundy的例子很好。

谷歌Guava库正在变得非常流行，它有一个通用的Function和Predicate对象，它们已经在API的许多部分中使用了这些对象。

当在一行中可以执行预定义数量的不同计算时，使用枚举是实现策略模式的一种快速而清晰的方法。

public enum Operation {
    PLUS {
        public double calc(double a, double b) {
            return a + b;
        }
    },
    TIMES {
        public double calc(double a, double b) {
            return a * b;
        }
    }
     ...

     public abstract double calc(double a, double b);
}

显然，策略方法声明以及每个实现的一个实例都定义在一个类/文件中。

在用Java编程时，我真正怀念的一件事是函数回调。在递归处理层次结构中，需要不断地呈现这些元素，您希望为每个元素执行特定的操作。比如遍历目录树，或者处理数据结构。我内心的极简主义者讨厌为每个特定的情况定义接口和实现。

有一天我发现自己在想为什么不呢?我们有方法指针——method对象。通过优化JIT编译器，反射调用实际上不再带来巨大的性能损失。此外，除了将文件从一个位置复制到另一个位置之外，反射方法调用的成本变得微不足道。

随着我对它的深入思考，我意识到OOP范式中的回调需要将对象和方法绑定在一起——进入回调对象。

请查看我的基于反射的Java回调解决方案。免费供任何用途。