看看lambdaj

http://code.google.com/p/lambdaj/

特别是它新的闭包特征

http://code.google.com/p/lambdaj/wiki/Closures

你会发现一种非常易读的方式来定义闭包或函数指针，而无需创建无意义的接口或使用丑陋的内部类

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

@sblundy的例子很好。

新的Java 8函数接口和方法引用使用::操作符。

Java 8能够使用“@ Functional Interface”指针维护方法引用(MyClass::new)。不需要相同的方法名称，只需要相同的方法签名。

例子:

@FunctionalInterface
interface CallbackHandler{
    public void onClick();
}

public class MyClass{
    public void doClick1(){System.out.println("doClick1");;}
    public void doClick2(){System.out.println("doClick2");}
    public CallbackHandler mClickListener = this::doClick;

    public static void main(String[] args) {
        MyClass myObjectInstance = new MyClass();
        CallbackHandler pointer = myObjectInstance::doClick1;
        Runnable pointer2 = myObjectInstance::doClick2;
        pointer.onClick();
        pointer2.run();
    }
}

那么，我们得到了什么?

function Interface——这是一个接口，无论是否带有@FunctionalInterface注释，它只包含一个方法声明。 方法引用-这只是特殊的语法，看起来像这样，objectInstance::methodName，不多不少。 用法示例-只是一个赋值操作符，然后调用接口方法。

您应该仅为侦听器使用函数接口，而且仅用于侦听器!

因为所有其他类似的函数指针都不利于代码的可读性和理解能力。然而，直接方法引用有时很方便，例如foreach。

有几个预定义的功能接口:

Runnable              -> void run( );
Supplier<T>           -> T get( );
Consumer<T>           -> void accept(T);
Predicate<T>          -> boolean test(T);
UnaryOperator<T>      -> T apply(T);
BinaryOperator<T,U,R> -> R apply(T, U);
Function<T,R>         -> R apply(T);
BiFunction<T,U,R>     -> R apply(T, U);
//... and some more of it ...
Callable<V>           -> V call() throws Exception;
Readable              -> int read(CharBuffer) throws IOException;
AutoCloseable         -> void close() throws Exception;
Iterable<T>           -> Iterator<T> iterator();
Comparable<T>         -> int compareTo(T);
Comparator<T>         -> int compare(T,T);

对于早期的Java版本，您应该尝试Guava库，正如Adrian Petrescu上面提到的，它具有类似的功能和语法。

如需进一步研究，请参阅Java 8 Cheatsheet

感谢戴帽子的家伙提供的Java语言规范§15.13链接。

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

匿名内部类

假设你想要传入一个带有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);

哇，为什么不创建一个Delegate类，这并不难，因为我已经为java做了，并使用它来传递参数，其中T是返回类型。我很抱歉，但作为一个c++ / c#程序员，一般只学习java，我需要函数指针，因为它们非常方便。如果你熟悉任何处理方法信息的类，你可以这样做。在java库中是java。lang。reflect。method。

如果你总是使用一个接口，你就必须实现它。在事件处理中，确实没有更好的方法来从处理程序列表中注册/取消注册，但对于委托，你需要传递函数而不是值类型，使委托类处理它outclasses一个接口。