The strategy pattern defines a family of algorithms encapsulated in a driver class usually known as Context and enables the algorithms to be interchangeable. It makes the algorithms easily interchangeable, and provides mechanism to choose the appropriate algorithm at a particular time.
The algorithms (strategies) are chosen at runtime either by a Client or by the Context. The Context class handles all the data during the interaction with the client.
The key participants of the Strategy pattern are represented below:
- Strategy – Specifies the interface for all algorithms. This interface is used to invoke the algorithms defined by a ConcreteStrategy.
- Context – Maintains a reference to a Strategy object.
- ConcreteStrategy – Actual implementation of the algorithm as per Strategy interface
Now let’s look at a concrete example of the strategy pattern and see how it gets transformed with lambda expressions. Suppose we have different type of rates for calculating income tax. Based on whether tax is paid in advance or late, there is a rebate or penalty, respectively. We can encapsulate this functionality in the same class as different methods but it would need modification to the class if some other tax calculation is required in future. This is not an efficient approach. Changes in implementation of a class should be the last resort.
Let’s take an optimal approach by using Strategy pattern. We will make an interface for Tax Strategy with a basic method:
public interface TaxStrategy {
public double calculateTax(double income);
}Now let’s define the concrete strategy for normal income tax.
public class PersonalTaxStrategy implements TaxStrategy {
public PersonalTaxStrategy() { }
@Override
public double calculateTax(double income) {
System.out.println("PersonalTax");
double tax = income * 0.3;
return tax;
}
}The PersonalTaxStrategy class conforms to the TaxStrategy interface. Similarly, let’s define a concrete strategy for late tax payment which incurs a penalty.
public class PersonalTaxPenaltyStrategy implements TaxStrategy {
public PersonalTaxPenaltyStrategy() { }
@Override
public double calculateTax(double income) {
System.out.println("PersonalTaxWithPenalty");
double tax = income * 0.4;
return tax;
}
}Next lets define a concrete strategy for advance tax payment which results in tax rebate.
public class PersonalTaxRebateStrategy implements TaxStrategy {
public PersonalTaxRebateStrategy() { }
@Override
public double calculateTax(double income) {
System.out.println("PersonalTaxWithRebate");
double tax = income * 0.2;
return tax;
}
}Now let’s combine all classes and interfaces defined to leverage the power of Strategy pattern. Let the main method act as Context for the different strategies. See just one sample interplay of all these classes:
import java.util.Arrays;
import java.util.List;
public class TaxStrategyMain {
public static void main(String [] args) {
//Create a List of Tax strategies for different scenarios
List<TaxStrategy> taxStrategyList =
Arrays.asList(
new PersonalTaxStrategy(),
new PersonalTaxPenaltyStrategy(),
new PersonalTaxRebateStrategy());
//Calculate Tax for different scenarios with corresponding strategies
for (TaxStrategy taxStrategy : taxStrategyList) {
System.out.println(taxStrategy.calculateTax(30000.0));
}
}
}Running this gives the following output:
PersonalTax
9000.0
PersonalTaxWithPenalty
12000.0
PersonalTaxWithRebate
6000.0
It clearly demonstrates how different tax rates can be calculated by using appropriate concrete strategy class. I have tried to combine all the concrete strategy (algorithms) in a list and then access them by iterating over the list.
What we have seen till now is just the standard strategy pattern and it’s been around for a long time. In these times when functional programming is the new buzzword one may ponder with the support of lambda expressions in Java, can things be done differently? Indeed, since the strategy interface is like a functional interface, we can rehash using lambda expressions in Java. Let’s see how the code looks like:
import java.util.Arrays;
import java.util.List;
public class TaxStrategyMainWithLambda {
public static void main(String [] args) {
//Create a List of Tax strategies for different scenarios with inline logic using Lambda
List<TaxStrategy> taxStrategyList =
Arrays.asList(
(income) -> { System.out.println("PersonalTax"); return 0.30 * income; },
(income) -> { System.out.println("PersonalTaxWithPenalty"); return 0.40 * income; },
(income) -> { System.out.println("PersonalTaxWithRebate"); return 0.20 * income; }
);
//Calculate Tax for different scenarios with corresponding strategies
taxStrategyList.forEach((strategy) -> System.out.println(strategy.calculateTax(30000.0)));
}
}Running this gives the similar output:
PersonalTax
9000.0
PersonalTaxWithPenalty
12000.0
PersonalTaxWithRebate
6000.0
We can see that use of lambda expressions, makes the additional classes for concrete strategies redundant. You don’t need additional classes; simply specify additional behavior using lambda expression.
- All the code snippets can be accessed from my github repo
| Reference: | Java 8 Lambda Expression for Design Patterns – Strategy Design Pattern from our JCG partner Gurpreet Sachdeva at the gssachdeva blog. |
