Java:Pushing runtime behaviour without Lambda
In Java8 one of the best features is Lambda Expression The Idea of Lambda expression is passing a behavior to a method.
This has been adopted from Functional programming, In Functional programming, we can pass a function as an argument of another function or can returns a function. The function takes a function as an argument or returns a function called
Higher order function.
The benefit of this type of design is you can pass behavior and values together, so a single function can perform all types of actions on those values.
Say, I want to create the calculator so in java we have to create methods like add, subtract, multiply etc. But in the functional program paradigm, we create one method which takes another method as an argument where we define what to do.
Pseudo code
Higher order function
function void caculate (a,b,f){
f(a,b);
}
Calling
calculate(10,20,funtion(y,z){// define and pass the method on fly
y+z;
});
In Java8 using Lambda, we can do the same if you want to know details about Lambda can consult my post http://javaonfly.blogspot.in/2016/08/java8-lambda.html
But here we will discuss How we can achieve the same thing without Lambda. As may, many projects has not adopted java 8 due to some restrictions.
We can achieve the same by using Interface and Anonymous class.
Step 1: Create an Interface which will provide the contract for the behavior/strategy, i.e add, subtract, multiply functionality.
So How we will achieve the same
package com.example.runtime.behaviour;
public interface IStrategy {
public void operation(int operand1,int operand2);
}
Step 2: Next I will create a Calculator class where we create a method called calculate which takes two operands and the IStrategy interface as arguments.
It acts like functional programming Higher order function where we can pass method/behavior runtime.
While calling this calculate method I pass the actual implementation of IStrategy interface by using Anonymous class.
By this way, we can push behavior on runtime without Lambda Expression.
package com.example.runtime.behaviour;
public class Calculator {
public void caculate(int operand1,int operand2,IStrategy runtimeBehaviour){
runtimeBehaviour.operation(operand1, operand2);
}
public static void testAllOperation(){
Calculator calc = new Calculator();
calc.caculate(10, 20, new IStrategy(){
@Override
public void operation(int operand1, int operand2) {
int result = operand1+operand2;
System.out.println("ADD:: " + result);
}
});
calc.caculate(10, 20, new IStrategy(){
@Override
public void operation(int operand1, int operand2) {
int result = operand1*operand2;
System.out.println("Multiply:: " + result);
}
});
}
public static void main(String[] args) {
Calculator.testAllOperation();
}
}
Look at the testAllOperationMethod here we pass two operands 10,20 and implementation of IStrategy one are for add another for multiplication.
So rather creating 4 different methods add, multiply, subtract, the division we can create one method which will support all possible operations taken on operand1 and operand2.
In Future, if any new operation like modulus will be added easily in this approach but if we use one method for one operation then you need to add a new method called modulus to Calculator class which will break Open close principle.
Posts
