Strategy Pattern

The Strategy pattern defines a family of algorithms and makes them interchangeable.

Core Structure

┌──────────────────────────┐
│       Context             │
├──────────────────────────┤
│ - strategy: Strategy     │
├──────────────────────────┤
│ + setStrategy(Strategy)  │
│ + executeStrategy()      │
└──────────┬───────────────┘
           │ uses
           ▼
┌──────────────────────────┐
│    «interface»           │
│      Strategy            │
├──────────────────────────┤
│ + execute(data): Result  │
└──────────┬───────────────┘
           │ implemented by
     ┌─────┴──────┐
     │            │
┌────┴─────┐ ┌───┴──────┐
│ConcreteA │ │ConcreteB │
└──────────┘ └──────────┘

Strategy Interface

// Strategy interface defines the algorithm contract
public interface SortStrategy {
    void sort(int[] array);
    String getName();
}

// Concrete strategies implement different algorithms
public class BubbleSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        // Bubble sort implementation
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    swap(array, j, j + 1);
                }
            }
        }
    }
    
    @Override
    public String getName() { return "Bubble Sort"; }
}

public class QuickSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        // QuickSort implementation
        quickSort(array, 0, array.length - 1);
    }
    
    @Override
    public String getName() { return "Quick Sort"; }
}

When to Define Strategy Interface

• Multiple algorithms for the same problem
• Algorithm selection at runtime
• Eliminating conditional statements
• Making algorithms interchangeable

Strategy Interface Guidelines

1. Small interface: 1-3 methods ideally
2. Clear contract: What the strategy does
3. No side effects: Strategy shouldn't modify context
4. Stateless when possible: Strategies without state are easier to reuse

Concrete strategies implement the strategy interface with specific algorithms.

Payment Processing Example

public interface PaymentStrategy {
    PaymentResult pay(Money amount, PaymentDetails details);
    boolean supportsRefund();
}

public class CreditCardStrategy implements PaymentStrategy {
    private final String cardNumber;
    private final String cvv;
    
    public CreditCardStrategy(String cardNumber, String cvv) {
        this.cardNumber = cardNumber;
        this.cvv = cvv;
    }
    
    @Override
    public PaymentResult pay(Money amount, PaymentDetails details) {
        // Credit card processing logic
        return new PaymentResult(true, "CC-" + UUID.randomUUID());
    }
    
    @Override
    public boolean supportsRefund() { return true; }
}

public class PayPalStrategy implements PaymentStrategy {
    private final String email;
    
    public PayPalStrategy(String email) {
        this.email = email;
    }
    
    @Override
    public PaymentResult pay(Money amount, PaymentDetails details) {
        // PayPal processing logic
        return new PaymentResult(true, "PP-" + UUID.randomUUID());
    }
    
    @Override
    public boolean supportsRefund() { return true; }
}

public class CryptoStrategy implements PaymentStrategy {
    @Override
    public PaymentResult pay(Money amount, PaymentDetails details) {
        // Cryptocurrency processing logic
        return new PaymentResult(true, "BTC-" + UUID.randomUUID());
    }
    
    @Override
    public boolean supportsRefund() { return false; }
}

Pricing Strategies

public interface PricingStrategy {
    Money calculatePrice(Order order);
}

public class RegularPricing implements PricingStrategy {
    public Money calculatePrice(Order order) {
        return order.getSubtotal();
    }
}

public class PremiumPricing implements PricingStrategy {
    private final double discountRate;
    
    public PremiumPricing(double discountRate) {
        this.discountRate = discountRate;
    }
    
    public Money calculatePrice(Order order) {
        return order.getSubtotal().multiply(1 - discountRate);
    }
}

public class BulkPricing implements PricingStrategy {
    public Money calculatePrice(Order order) {
        if (order.getItemCount() >= 10) {
            return order.getSubtotal().multiply(0.8); // 20% off
        }
        return order.getSubtotal();
    }
}

Strategy Selection

Strategy	Use When
RegularPricing	Default pricing
PremiumPricing	Subscription users
BulkPricing	Large orders
PromoPricing	Active promotion

The Context class uses the strategy and allows swapping strategies at runtime.

Context Implementation

public class PriceCalculator {
    private PricingStrategy strategy;
    
    // Constructor injection
    public PriceCalculator(PricingStrategy strategy) {
        this.strategy = strategy;
    }
    
    // Setter injection for runtime swapping
    public void setStrategy(PricingStrategy strategy) {
        this.strategy = strategy;
    }
    
    public Money calculate(Order order) {
        return strategy.calculatePrice(order);
    }
}

Context with Strategy Selection

public class PaymentService {
    private final Map<PaymentType, PaymentStrategy> strategies;
    
    public PaymentService() {
        strategies = new HashMap<>();
        strategies.put(PaymentType.CREDIT_CARD, new CreditCardStrategy());
        strategies.put(PaymentType.PAYPAL, new PayPalStrategy());
        strategies.put(PaymentType.CRYPTO, new CryptoStrategy());
    }
    
    public PaymentResult processPayment(Order order, PaymentType type) {
        PaymentStrategy strategy = strategies.get(type);
        if (strategy == null) {
            throw new UnsupportedPaymentType(type);
        }
        return strategy.pay(order.getTotal(), order.getPaymentDetails());
    }
}

Runtime Strategy Swapping

// Start with regular pricing
PriceCalculator calculator = new PriceCalculator(new RegularPricing());
Money price = calculator.calculate(order); // Regular price

// User becomes premium member
calculator.setStrategy(new PremiumPricing(0.1));
price = calculator.calculate(order); // 10% discount

// During bulk promotion
calculator.setStrategy(new BulkPricing());
price = calculator.calculate(order); // Bulk discount if applicable

Strategy with Dependency Injection

// Spring-style injection
@Service
public class OrderService {
    private final PricingStrategy pricingStrategy;
    
    @Autowired
    public OrderService(PricingStrategy pricingStrategy) {
        this.pricingStrategy = pricingStrategy;
    }
    
    public Order calculateOrder(Order order) {
        Money total = pricingStrategy.calculatePrice(order);
        order.setTotal(total);
        return order;
    }
}

// Different beans for different strategies
@Configuration
public class PricingConfig {
    @Bean
    @Profile("default")
    public PricingStrategy regularPricing() {
        return new RegularPricing();
    }
    
    @Bean
    @Profile("premium")
    public PricingStrategy premiumPricing() {
        return new PremiumPricing(0.15);
    }
}

Benefits of Strategy Pattern

1. Open-Closed Principle: Add new strategies without modifying context
2. Eliminates conditionals: No if/else chains for algorithm selection
3. Runtime flexibility: Swap algorithms during execution
4. Testability: Test each strategy in isolation
5. Reusability: Strategies can be shared across contexts