看看lambdaj

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

特别是它新的闭包特征

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

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

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

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 7中涉及闭包的工作感兴趣:

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

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

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

@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);

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

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

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