匿名内部类

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

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

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

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

@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)语句，它调用一行或另一行。

在没有函数数组接口的情况下做同样的事情:

class NameFuncPair
{
    public String name;                // name each func
    void   f(String x) {}              // stub gets overridden
    public NameFuncPair(String myName) { this.name = myName; }
}

public class ArrayOfFunctions
{
    public static void main(String[] args)
    {
        final A a = new A();
        final B b = new B();

        NameFuncPair[] fArray = new NameFuncPair[]
        {
            new NameFuncPair("A") { @Override void f(String x) { a.g(x); } },
            new NameFuncPair("B") { @Override void f(String x) { b.h(x); } },
        };

        // Go through the whole func list and run the func named "B"
        for (NameFuncPair fInstance : fArray)
        {
            if (fInstance.name.equals("B"))
            {
                fInstance.f(fInstance.name + "(some args)");
            }
        }
    }
}

class A { void g(String args) { System.out.println(args); } }
class B { void h(String args) { System.out.println(args); } }

看看lambdaj

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

特别是它新的闭包特征

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

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