How to implement inheritance with Java-8? - java-8

Question

I have a program with AddService class which is implementing IService interface as follows:
IService.java
public interface IService {
Integer add(int x, int y);
}
AddService.java
import com.test.service.IService;
public class AddService implements IService {
#Override
public Integer add(int x, int y) {
return x + y;
}
}
Above code compiles and run fine, but as soon as I change above implementation using Java-8 provided BiFunction as below, IDE starts complaining at compile time.
IService.java
import java.util.function.BiFunction;
public interface IService {
BiFunction<Integer, Integer, Integer> add( x, y);
}
AddService.java
import java.util.function.BiFunction;
import com.test.service.IService;
public class AddService implements IService {
#Override
public BiFunction<Integer, Integer, Integer> add = (x, y) -> {
return x + y;
};
}
Any idea how I can resolve the error and make my program run?

Answer 1

Lambda expressions enable you to express code as data. You could write:
IService addService = (x, y) -> x + y;
which declares a variable addService that implements IService. Better, get rid of IService and use IntBinaryOperator:
IntBinaryOperator add = (x, y) -> x + y;
IntBinaryOperator subtract = (x, y) -> x - y;
...
and use add where you would have otherwise used new AddService().

Answer 2

Assuming that IService is creates for a reason and the actual implementations are non trivial, I would write a non-trival implementation like this.
public interface IService {
int op(int x, int y);
}
public enum OpService implements IService {
ADD {
#Override
public int op(int x, int y) {
return x + y;
}
},
MINUS {
#Override
public int op(int x, int y) {
return x - y;
}
}
}
class A {
public static void main(String[] args) {
IntBinaryOperator add = OpService.ADD::op;
IntBinaryOperator minus = OpService.MINUS::op;
System.out.println(add.applyAsInt(2, 3));
}
}
prints
5
However, if all you want to do is add two numbers together I would just use +

Answer 3

You misunderstand. Assume you have a method like
public void someMethod(IService addService) {
System.out.println(addService.add(2, 4));
}
With Java 8, you're now allowed to call that method like
public void anotherMethod() {
someMethod((x, y) -> x + y);
}
instead of having to properly implement IService and do something like
public void anotherMethod() {
someMethod(new AddService());
}
A lambda can serve as implementation to all functional interfaces. The BiFunction interface exists so that you don't even have to add the IService interface. You could instead just do
public void someMethod2(BiFunction<Integer, Integer, Integer> addService) {
System.out.println(addService.apply(2, 4));
}
public void anotherMethod() {
someMethod((x, y) -> x + y);
}
and it would still work. The identical lamda will this time be treated as BiFunction instead of IService.