Callback with 3 parameters

In modern Java, using a callback (a.k.a. function reference a.k.a. function pointer) with up to two parameters is pleasantly easy and straightforward. Example:

class a {
  public static Object plus(Object a, Object b) {
    return (Double) a + (Double) b;
  }

  public static void main(String[] args) {
    BiFunction<Object, Object, Object> f = a::plus;
    System.out.println(f.apply(2.0, 3.0));
  }
}

(The parameters and return value can be typed, though they have to be object references, not primitives.)

The compiler directly knows about java.util.function.BiFunction and its smaller kin, as can be seen in the disassembly of the above main:

     0: invokedynamic #17,  0             // InvokeDynamic #0:apply:()Ljava/util/function/BiFunction;
     5: astore_1
     6: getstatic     #21                 // Field java/lang/System.out:Ljava/io/PrintStream;
     9: aload_1
    10: ldc2_w        #27                 // double 2.0d
    13: invokestatic  #13                 // Method java/lang/Double.valueOf:(D)Ljava/lang/Double;
    16: ldc2_w        #29                 // double 3.0d
    19: invokestatic  #13                 // Method java/lang/Double.valueOf:(D)Ljava/lang/Double;
    22: invokeinterface #31,  3           // InterfaceMethod java/util/function/BiFunction.apply:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
    27: invokevirtual #36                 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
    30: return

There is, however, no java.util.function.TriFunction.

How do you set up a callback with three parameters?

Just create your own TriFunction functional interface. Let's keep it simple and omit all the default methods for now:

@FunctionalInterface
interface TriFunction<T, U, V, R> {

    R apply(T t, U u, V v);
}

The annotation is optional, but it will cause a compiler error if you add another non-default method.

From a functional programing perspective you solve this with currying. Meaning your function return another function. You can pass the Function to methods (or other functions).

Here is your example with currying:

import java.util.function.Function;

public class A {

    public static Function<Double, Function<Double, Function<Double, Double>>> plus = a -> b -> c -> a + b + c;
    public static Function<Double, Function<Double, Function<Double, Double>>> multiply = a -> b -> c -> a * b * c;

    public static double doMath(double a, double b, double c, Function<Double, Function<Double, Function<Double, Double>>> calc) {
        return calc.apply(a).apply(b).apply(c);
    }

    public static void main(String[] args) {
        System.out.println("Plus:     " + doMath(2, 3, 4, plus));
        System.out.println("Multiply: " + doMath(2, 3, 4, multiply));
    }
}