Unlocking Flexibility: The Strategy Design Pattern

Introduction

In software development, we often encounter situations where we need to handle multiple strategies or algorithms dynamically. For example, in an e-commerce application, we may need to apply different discount strategies based on user behavior. The Strategy Design Pattern provides a solution to this problem by allowing us to define a family of algorithms, encapsulate each algorithm, and make them interchangeable at runtime.

Example Scenarios

• Payment Methods: Consider an application that handles payments. It offers various payment methods such as credit cards, UPI, and wallets. Each payment method has its own implementation. The challenge is to keep the core logic (runner class) loosely coupled with these payment strategies, allowing for easy inclusion of new payment methods.
• Gaming Strategies: In a game, different enemy strategies may need to be implemented. The Strategy Pattern enables the game to switch between these strategies based on the game state.
• E-Commerce Discounts: E-commerce platforms often offer discounts based on user behavior or purchase history. The Strategy Pattern can be used to define and apply these discounts dynamically.
• Compression Algorithms: Different algorithms may be used for compressing files (e.g., ZIP). The Strategy Pattern can be used to switch between these algorithms based on the user's needs.

The Strategy Design Pattern

The Strategy Design Pattern, also known as the Policy Pattern, provides a solution to these problems. It's a behavioral design pattern that allows an object's behavior to be selected at runtime, providing flexibility and reusability in software design.

Benefits of the Strategy Design Pattern:

• Improved code reusability: Strategies can be reused across different parts of the application.
• Easy addition of new strategies: New strategies can be added without modifying existing code.
• Flexible and maintainable code: The pattern allows for easy modification of the algorithm's logic with minimal impact on the rest of the codebase.

Implementation

1. Define the Strategy Interface: Create an interface that declares a method for the algorithm. This interface will be implemented by concrete strategy classes.

public interface PaymentStrategy {
    void pay(int amount);
}        

2. Create Concrete Strategy Classes: Implement the interface in multiple classes, each providing a different implementation of the algorithm.

class PayPalPaymentStrategy implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using PayPal");
    }
}

class GooglePayPaymentStrategy implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using Google Pay");
    }
}        

3. Create the Context Class: Create a class that contains a reference to the strategy interface. This class will allow clients to change the algorithm dynamically.

class PaymentContext {
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void makePayment(int amount) {
        paymentStrategy.pay(amount);
    }
}        

4. Use the Strategy Pattern: Create an instance of the context class and pass different strategy objects to it. The context class will delegate the algorithm's execution to the current strategy object.

public class Main {
    public static void main(String[] args) {
        PaymentContext context = new PaymentContext();

        // Using Credit Card
        context.setPaymentStrategy(new CreditCardPaymentStrategy());
        context.makePayment(100);

        // Using PayPal
        context.setPaymentStrategy(new PayPalPaymentStrategy());
        context.makePayment(50);

        // Using Google Pay
        context.setPaymentStrategy(new GooglePayPaymentStrategy());
        context.makePayment(75);
    }
}        

UML Diagram

Conclusion

The Strategy Design Pattern is a powerful tool in software design, especially in scenarios where multiple strategies or algorithms need to be handled dynamically. By encapsulating each algorithm into its own class and making them interchangeable at runtime, the pattern promotes code reusability, maintainability, and flexibility. Consider using the Strategy Pattern in your projects to improve the design and maintainability of your software.