Java 中最接近函数指针的替代品是什么？

Question

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

Answer 1

匿名内部类

假设您希望传入一个带有 String 参数的函数，该参数返回 int。
首先，如果您不能重用现有接口，则必须定义一个接口，该接口作为其唯一成员。

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

Answer 2

对于每个“函数指针”，我会创建一个小的 functor class 来实现您的计算。 定义一个所有类都将实现的接口，并将这些对象的实例传递给更大的函数。这是“command pattern”和“strategy pattern”的组合。

@sblundy 的例子很好。

Answer 3

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

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

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

Answer 4

您需要创建一个接口来提供您想要传递的功能。例如：

/**
 * A simple interface to wrap up a function of one argument.
 * 
 * @author rcreswick
 *
 */
public interface Function1<S, T> {

   /**
    * Evaluates this function on it's arguments.
    * 
    * @param a The first argument.
    * @return The result.
    */
   public S eval(T a);

}

然后，当你需要传递一个函数时，你可以实现那个接口：

List<Integer> result = CollectionUtilities.map(list,
        new Function1<Integer, Integer>() {
           @Override
           public Integer eval(Integer a) {
              return a * a;
           }
        });

最后map函数使用传入的Function1如下：

   public static <K,R,S,T> Map<K, R> zipWith(Function2<R,S,T> fn, 
         Map<K, S> m1, Map<K, T> m2, Map<K, R> results){
      Set<K> keySet = new HashSet<K>();
      keySet.addAll(m1.keySet());
      keySet.addAll(m2.keySet());

      results.clear();

      for (K key : keySet) {
         results.put(key, fn.eval(m1.get(key), m2.get(key)));
      }
      return results;
   }

如果您不需要传入参数，您通常可以使用 Runnable 代替您自己的接口，或者您可以使用各种其他技术来使参数计数不那么“固定”，但这通常是与类型安全的权衡. （或者你可以重写你的函数对象的构造函数，以这种方式传递参数。有很多方法，有些在某些情况下效果更好。）

Answer 5

使用:: 运算符的方法引用

您可以在方法接受功能接口的方法参数中使用方法引用。功能接口是任何只包含一个抽象方法的接口。 （一个函数式接口可能包含一个或多个默认方法或静态方法。）

IntBinaryOperator 是一个功能接口。它的抽象方法applyAsInt 接受两个ints 作为其参数并返回一个int。 Math.max 也接受两个ints 并返回一个int。在此示例中，A.method(Math::max); 使 parameter.applyAsInt 将其两个输入值发送到 Math.max 并返回该 Math.max 的结果。

import java.util.function.IntBinaryOperator;

class A {
    static void method(IntBinaryOperator parameter) {
        int i = parameter.applyAsInt(7315, 89163);
        System.out.println(i);
    }
}

import java.lang.Math;

class B {
    public static void main(String[] args) {
        A.method(Math::max);
    }
}

一般来说，你可以使用：

method1(Class1::method2);

代替：

method1((arg1, arg2) -> Class1.method2(arg1, arg2));

简称：

method1(new Interface1() {
    int method1(int arg1, int arg2) {
        return Class1.method2(arg1, agr2);
    }
});

有关详细信息，请参阅:: (double colon) operator in Java 8 和 Java Language Specification §15.13。

Answer 6

您也可以这样做（这在某些 RARE 场合是有意义的）。问题（这是一个大问题）是您失去了使用类/接口的所有类型安全性，并且您必须处理该方法不存在的情况。

它确实具有“好处”，您可以忽略访问限制并调用私有方法（示例中未显示，但您可以调用编译器通常不允许您调用的方法）。

同样，这是有道理的罕见情况，但在这种情况下，它是一个不错的工具。

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

class Main
{
    public static void main(final String[] argv)
        throws NoSuchMethodException,
               IllegalAccessException,
               IllegalArgumentException,
               InvocationTargetException
    {
        final String methodName;
        final Method method;
        final Main   main;

        main = new Main();

        if(argv.length == 0)
        {
            methodName = "foo";
        }
        else
        {
            methodName = "bar";
        }

        method = Main.class.getDeclaredMethod(methodName, int.class);

        main.car(method, 42);
    }

    private void foo(final int x)
    {
        System.out.println("foo: " + x);
    }

    private void bar(final int x)
    {
        System.out.println("bar: " + x);
    }

    private void car(final Method method,
                     final int    val)
        throws IllegalAccessException,
               IllegalArgumentException,
               InvocationTargetException
    {
        method.invoke(this, val);
    }
}

Answer 7

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

Answer 8

您可能也有兴趣了解 Java 7 正在进行的涉及闭包的工作：

What’s the current state of closures in Java?

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

Answer 9

使用 :: 运算符的新 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();
    }
}

那么，我们这里有什么？

1. Functional Interface - 这是一个接口，用 @FunctionalInterface 注释与否，它只包含一个方法声明。
2. 方法引用 - 这只是特殊语法，看起来像这样，objectInstance::methodName，仅此而已。
3. 使用示例 - 只是一个赋值运算符，然后是接口方法调用。

您应该仅为侦听器使用功能接口，并且仅用于此目的！

因为所有其他此类函数指针对代码的可读性和理解能力都非常不利。但是，直接方法引用有时会派上用场，例如 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 Libraries，它具有类似的功能和语法，正如 Adrian Petrescu 上面提到的那样。

更多研究请查看Java 8 Cheatsheet

感谢戴帽子的家伙提供Java Language Specification §15.13 链接。

Answer 10

@sblundy 的回答很好，但匿名内部类有两个小缺陷，主要是它们往往不可重用，其次是语法庞大。

好消息是他的模式扩展到完整的类，而主类（执行计算的类）没有任何变化。

当您实例化一个新类时，您可以将参数传递给该类，这些参数可以在您的方程式中充当常量——因此，如果您的内部类之一看起来像这样：

f(x,y)=x*y

但有时您需要的是：

f(x,y)=x*y*2

也许还有三分之一：

f(x,y)=x*y/2

您可以创建一个实例化为单个 ACTUAL 类，而不是创建两个匿名内部类或添加“passthrough”参数：

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

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

我真的只是发布这个，因为每当我听到匿名内部类时我都会畏缩——我看到很多冗余代码是“必需的”，因为程序员做的第一件事就是在他应该使用实际的上课，从未重新考虑过他的决定。

Answer 11

正在变得非常流行的 Google Guava libraries 有一个通用的 Function 和 Predicate 对象，他们已将其应用于其 API 的许多部分。

Answer 12

在使用 Java 编程时，我真正怀念的一件事是函数回调。需要这些不断呈现的一种情况是在递归处理层次结构时，您希望对每个项目执行一些特定的操作。就像遍历目录树或处理数据结构一样。我内心的极简主义者讨厌必须定义一个接口，然后为每个特定情况定义一个实现。

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

我越想越明白，OOP 范式中的回调需要将对象和方法绑定在一起——进入回调对象。

查看我针对Callbacks in Java 的基于反射的解决方案。免费供任何使用。

Answer 13

对我来说，这听起来像是一种策略模式。查看 fluffycat.com Java 模式。

Answer 14

好的，这个帖子已经够老了，所以很可能我的回答对这个问题没有帮助。不过既然这个帖子帮我找到了解决办法，我还是把它放在这里。

我需要使用具有已知输入和已知输出（均 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);

其中活动是任意的双精度值。我正在考虑可能会像 SoftwareMonkey 所做的那样更抽象和概括它，但目前我对它的方式感到满意。三行代码，不需要类和接口，还不错。

Answer 15

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

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

Answer 16

查看 lambdaj

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

尤其是它的新关闭功能

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

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

Answer 17

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

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

Answer 18

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

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

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

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

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

Answer 19

如果有人正在努力传递一个函数，该函数需要一组参数来定义其行为，但要执行另一组参数，例如 Scheme 的：

(define (function scalar1 scalar2)
  (lambda (x) (* x scalar1 scalar2)))

见Pass Function with Parameter-Defined Behavior in Java

Answer 20

从 Java8 开始，您可以使用 lambda，它在官方 SE 8 API 中也有库。

用法： 您需要使用只有一个抽象方法的接口。 像这样创建它的一个实例（您可能希望使用已经提供的 java SE 8）：

Function<InputType, OutputType> functionname = (inputvariablename) {
... 
return outputinstance;
}

有关更多信息，请查看文档：https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

Answer 21

在 Java 8 之前，最接近类似函数指针功能的替代品是匿名类。例如：

Collections.sort(list, new Comparator<CustomClass>(){
    public int compare(CustomClass a, CustomClass b)
    {
        // Logic to compare objects of class CustomClass which returns int as per contract.
    }
});

但现在在 Java 8 中，我们有一个非常简洁的替代方案，称为 lambda expression，它可以用作：

list.sort((a, b) ->  { a.isBiggerThan(b) } );

其中 isBiggerThan 是 CustomClass 中的一个方法。我们也可以在这里使用方法引用：

list.sort(MyClass::isBiggerThan);

Answer 22

开源safety-mirror 项目将上述一些解决方案推广到一个库中，为Java 添加函数、委托和事件。

请参阅自述文件或this stackoverflow answer，了解功能备忘单。

对于函数，该库引入了一个 Fun 接口，以及一些子接口（与泛型一起）构成了一个流畅的 API，用于将方法用作类型。

Fun.With0Params<String> myFunctionField = "   hello world   "::trim;`  
Fun.With2Params<Boolean, Object, Object> equals = Objects::equals;`  
    
public void foo(Fun.With1ParamAndVoid<String> printer) throws Exception {
    printer.invoke("hello world);
}  

public void test(){
    foo(System.out::println);
}  

注意：

1. 您必须选择与您所定位的签名中的参数数量相匹配的子接口。 Fx，如果只有一个参数，选择 Fun.With1Param。
2. 泛型用于定义 A) 返回类型和 B) 签名的参数。

另外，请注意传递给 foo() 方法调用的方法引用的签名必须与方法 Foo 定义的 Fun 匹配。如果没有，编译器会报错。