This is related to this question: How to do function composition?
I noticed that a method reference can be assigned to a variable declared as Function
, and so I assume it should have andThen
or compose
function, and hence I expect that we can compose them directly. But apparently we need to assign them to a variable declared as Function
first (or type-cast before invocation) before we can call andThen
or compose
on them.
I suspect I might have some misconception about how this should work.
So my questions:
- Why do we need to type-cast or assign it to a variable first before we can call the
andThen
method? - What exactly is the type of method reference that it needs to be done in this way?
Sample code below.
public class MyMethods{
public static Integer triple(Integer a){return 3*a;}
public static Integer quadruple(Integer a){return 4*a;}
public int operate(int num, Function<Integer, Integer> f){
return f.apply(num);
}
public static void main(String[] args){
MyMethods methods = new MyMethods();
int three = methods.operate(1, MyMethods::triple); // This is fine
// Error below
// int twelve = methods.operate(1, (MyMethods::triple).andThen(MyMethods::quadruple));
// But this one is fine
Function<Integer, Integer> triple = MyMethods::triple;
Function<Integer, Integer> quadruple = MyMethods::quadruple;
int twelve = methods.operate(1, triple.andThen(quadruple));
// This one is also fine
int twelve2 = methods.operate(1, ((Function<Integer, Integer>)MyMethods::triple).andThen(MyMethods::quadruple));
}
}
More description on the error
In Eclipse it's highlighted with the error message:
The target type of this expression must be a functional interface
and in Java 8 compiler the error is:
java8test.java:14: error: method reference not expected here int twelve = methods.operate(1, (MyMethods::triple).andThen(MyMethods::quadruple)); ^ 1 error
(actually, why is the error in Eclipse different from the one from Java 8 compiler?)