我有一个方法,大约有十行代码。我想创建更多的方法来做完全相同的事情,除了一个会改变一行代码的小计算。这是一个传递函数指针来替换这一行的完美应用程序,但是Java没有函数指针。我最好的选择是什么?


当前回答

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

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

其他回答

好吧,这个帖子已经足够老了,所以我的回答很可能对这个问题没有帮助。但是因为这个帖子帮助我找到了我的解决方案,我还是把它放在这里。

我需要使用一个具有已知输入和已知输出(都是double)的变量静态方法。因此,知道了方法包和名称后,我可以这样工作:

java.lang.reflect.Method Function = Class.forName(String classPath).getMethod(String method, Class[] params);

对于接受一个double作为参数的函数。

在具体情况下,我用

java.lang.reflect.Method Function = Class.forName("be.qan.NN.ActivationFunctions").getMethod("sigmoid", double.class);

并在以后更复杂的情况下调用它

return (java.lang.Double)this.Function.invoke(null, args);

java.lang.Object[] args = new java.lang.Object[] {activity};
someOtherFunction() + 234 + (java.lang.Double)Function.invoke(null, args);

activity是任意的双精度值。我正在考虑可能做得更抽象和一般化一点,就像SoftwareMonkey所做的那样,但目前我对它的方式很满意。三行代码,没有必要的类和接口,还不错。

匿名内部类

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

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

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

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

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

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

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

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

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

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