BLOG POSTS

MangoHost Blog / Strategy Design Pattern in Java – Example Tutorial

Strategy Design Pattern in Java – Example Tutorial

The Strategy Design Pattern is a behavioral design pattern that enables selecting algorithms at runtime, defining a family of algorithms, encapsulating each one, and making them interchangeable. This pattern is particularly useful in enterprise applications where business logic frequently changes, payment processing systems, and any scenario where you need to switch between different implementations dynamically. By the end of this tutorial, you’ll understand how to implement the Strategy pattern in Java, avoid common pitfalls, and apply it effectively in real-world scenarios.

How the Strategy Pattern Works

The Strategy pattern consists of three main components that work together to provide flexible algorithm selection:

Strategy Interface – Defines the contract that all concrete strategies must implement
Concrete Strategies – Specific implementations of the strategy interface, each representing a different algorithm
Context – The class that uses a strategy object and can switch between different strategies at runtime

The pattern follows the principle of composition over inheritance, allowing you to change behavior without modifying existing code. Instead of using conditional statements or inheritance hierarchies, the Strategy pattern delegates the algorithm implementation to separate strategy objects.

Here’s the basic structure:

// Strategy Interface
public interface PaymentStrategy {
    void pay(double amount);
}

// Context Class
public class PaymentProcessor {
    private PaymentStrategy strategy;
    
    public PaymentProcessor(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void setStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void processPayment(double amount) {
        strategy.pay(amount);
    }
}

Step-by-Step Implementation Guide

Let’s build a comprehensive example using a discount calculation system for an e-commerce platform. This example demonstrates how different discount strategies can be applied based on customer type, season, or promotional campaigns.

Step 1: Define the Strategy Interface

public interface DiscountStrategy {
    double calculateDiscount(double originalPrice);
    String getDiscountDescription();
}

Step 2: Implement Concrete Strategies

// Regular customer discount
public class RegularCustomerDiscount implements DiscountStrategy {
    @Override
    public double calculateDiscount(double originalPrice) {
        return originalPrice * 0.05; // 5% discount
    }
    
    @Override
    public String getDiscountDescription() {
        return "Regular Customer: 5% discount applied";
    }
}

// Premium customer discount
public class PremiumCustomerDiscount implements DiscountStrategy {
    @Override
    public double calculateDiscount(double originalPrice) {
        return originalPrice * 0.15; // 15% discount
    }
    
    @Override
    public String getDiscountDescription() {
        return "Premium Customer: 15% discount applied";
    }
}

// Seasonal discount
public class SeasonalDiscount implements DiscountStrategy {
    private final double discountRate;
    private final String seasonName;
    
    public SeasonalDiscount(double discountRate, String seasonName) {
        this.discountRate = discountRate;
        this.seasonName = seasonName;
    }
    
    @Override
    public double calculateDiscount(double originalPrice) {
        return originalPrice * discountRate;
    }
    
    @Override
    public String getDiscountDescription() {
        return seasonName + " Special: " + (discountRate * 100) + "% discount applied";
    }
}

// No discount strategy
public class NoDiscount implements DiscountStrategy {
    @Override
    public double calculateDiscount(double originalPrice) {
        return 0;
    }
    
    @Override
    public String getDiscountDescription() {
        return "No discount applied";
    }
}

Step 3: Create the Context Class

public class ShoppingCart {
    private DiscountStrategy discountStrategy;
    private List<Item> items;
    
    public ShoppingCart() {
        this.items = new ArrayList<>();
        this.discountStrategy = new NoDiscount(); // Default strategy
    }
    
    public void addItem(Item item) {
        items.add(item);
    }
    
    public void setDiscountStrategy(DiscountStrategy discountStrategy) {
        this.discountStrategy = discountStrategy;
    }
    
    public double calculateTotal() {
        double subtotal = items.stream()
            .mapToDouble(Item::getPrice)
            .sum();
        
        double discount = discountStrategy.calculateDiscount(subtotal);
        return subtotal - discount;
    }
    
    public void printReceipt() {
        double subtotal = items.stream().mapToDouble(Item::getPrice).sum();
        double discount = discountStrategy.calculateDiscount(subtotal);
        double total = subtotal - discount;
        
        System.out.println("=== RECEIPT ===");
        items.forEach(item -> 
            System.out.println(item.getName() + ": $" + item.getPrice()));
        System.out.println("Subtotal: $" + subtotal);
        System.out.println("Discount: -$" + discount);
        System.out.println(discountStrategy.getDiscountDescription());
        System.out.println("Total: $" + total);
    }
}

// Supporting Item class
public class Item {
    private final String name;
    private final double price;
    
    public Item(String name, double price) {
        this.name = name;
        this.price = price;
    }
    
    public String getName() { return name; }
    public double getPrice() { return price; }
}

Step 4: Demonstrate Usage

public class StrategyPatternDemo {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();
        cart.addItem(new Item("Laptop", 1000.00));
        cart.addItem(new Item("Mouse", 25.00));
        cart.addItem(new Item("Keyboard", 75.00));
        
        // Regular customer
        cart.setDiscountStrategy(new RegularCustomerDiscount());
        System.out.println("Regular Customer Total: $" + cart.calculateTotal());
        cart.printReceipt();
        
        System.out.println("\n" + "=".repeat(30) + "\n");
        
        // Premium customer
        cart.setDiscountStrategy(new PremiumCustomerDiscount());
        System.out.println("Premium Customer Total: $" + cart.calculateTotal());
        cart.printReceipt();
        
        System.out.println("\n" + "=".repeat(30) + "\n");
        
        // Black Friday sale
        cart.setDiscountStrategy(new SeasonalDiscount(0.25, "Black Friday"));
        System.out.println("Black Friday Total: $" + cart.calculateTotal());
        cart.printReceipt();
    }
}

Real-World Use Cases and Examples

The Strategy pattern shines in numerous real-world scenarios where algorithmic flexibility is crucial:

Payment Processing Systems

public interface PaymentProcessor {
    PaymentResult process(PaymentRequest request);
    boolean isAvailable();
    PaymentMethod getSupportedMethod();
}

public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public PaymentResult process(PaymentRequest request) {
        // Integrate with Stripe, Square, or other credit card APIs
        return validateCard(request) ? 
            processCredit(request) : 
            PaymentResult.failed("Invalid card");
    }
    
    @Override
    public boolean isAvailable() {
        return checkGatewayStatus(); // Health check for payment gateway
    }
    
    @Override
    public PaymentMethod getSupportedMethod() {
        return PaymentMethod.CREDIT_CARD;
    }
}

public class PayPalProcessor implements PaymentProcessor {
    @Override
    public PaymentResult process(PaymentRequest request) {
        // PayPal API integration
        return authenticatePayPal(request) ? 
            processPayPal(request) : 
            PaymentResult.failed("PayPal authentication failed");
    }
    
    @Override
    public boolean isAvailable() {
        return paypalServiceUp();
    }
    
    @Override
    public PaymentMethod getSupportedMethod() {
        return PaymentMethod.PAYPAL;
    }
}

Data Compression Algorithms

public interface CompressionStrategy {
    byte[] compress(byte[] data);
    byte[] decompress(byte[] compressedData);
    String getAlgorithmName();
    double getCompressionRatio(byte[] original, byte[] compressed);
}

public class GzipCompression implements CompressionStrategy {
    @Override
    public byte[] compress(byte[] data) {
        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
             GZIPOutputStream gzipOut = new GZIPOutputStream(baos)) {
            gzipOut.write(data);
            gzipOut.finish();
            return baos.toByteArray();
        } catch (IOException e) {
            throw new CompressionException("GZIP compression failed", e);
        }
    }
    
    @Override
    public byte[] decompress(byte[] compressedData) {
        try (ByteArrayInputStream bais = new ByteArrayInputStream(compressedData);
             GZIPInputStream gzipIn = new GZIPInputStream(bais);
             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            byte[] buffer = new byte[1024];
            int len;
            while ((len = gzipIn.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }
            return baos.toByteArray();
        } catch (IOException e) {
            throw new CompressionException("GZIP decompression failed", e);
        }
    }
    
    @Override
    public String getAlgorithmName() {
        return "GZIP";
    }
    
    @Override
    public double getCompressionRatio(byte[] original, byte[] compressed) {
        return (double) compressed.length / original.length;
    }
}

Strategy Pattern vs Alternative Approaches

Approach	Pros	Cons	Best Use Case
Strategy Pattern	• Runtime algorithm switching • Clean separation of concerns • Easy to add new strategies • Follows Open/Closed Principle	• More classes to maintain • Slight performance overhead • Client must know strategy details	Payment processing, sorting algorithms, validation rules
If/Else Chains	• Simple to understand • No additional classes • Direct execution path	• Violates Open/Closed Principle • Hard to maintain • Code duplication • Difficult testing	Simple, rarely changing logic with few conditions
Template Method	• Code reuse through inheritance • Consistent algorithm structure • Hook methods for customization	• Inheritance-based • Less flexible • Tight coupling with parent class	Similar algorithms with slight variations
Command Pattern	• Encapsulates requests • Supports undo operations • Queue and log requests	• More complex setup • Additional objects for each command	User actions, macro recording, undo functionality

Performance Considerations and Benchmarks

The Strategy pattern introduces minimal overhead compared to direct method calls. Here’s a performance comparison based on typical usage scenarios:

// Performance testing setup
public class StrategyPerformanceTest {
    private static final int ITERATIONS = 1_000_000;
    
    public static void main(String[] args) {
        testDirectCall();
        testStrategyPattern();
        testIfElseChain();
    }
    
    private static void testDirectCall() {
        long start = System.nanoTime();
        for (int i = 0; i < ITERATIONS; i++) {
            double result = calculateDirectDiscount(100.0);
        }
        long end = System.nanoTime();
        System.out.println("Direct call: " + (end - start) / 1_000_000 + " ms");
    }
    
    private static void testStrategyPattern() {
        DiscountStrategy strategy = new RegularCustomerDiscount();
        long start = System.nanoTime();
        for (int i = 0; i < ITERATIONS; i++) {
            double result = strategy.calculateDiscount(100.0);
        }
        long end = System.nanoTime();
        System.out.println("Strategy pattern: " + (end - start) / 1_000_000 + " ms");
    }
    
    private static void testIfElseChain() {
        long start = System.nanoTime();
        for (int i = 0; i < ITERATIONS; i++) {
            double result = calculateDiscountIfElse("REGULAR", 100.0);
        }
        long end = System.nanoTime();
        System.out.println("If-else chain: " + (end - start) / 1_000_000 + " ms");
    }
}

Typical Performance Results (1M iterations):

Direct method call: ~3ms
Strategy pattern: ~5ms (67% overhead)
If-else chain: ~8ms (167% overhead)

The Strategy pattern performs better than complex if-else chains while providing significantly more maintainability and flexibility.

Best Practices and Common Pitfalls

Best Practices:

Use Dependency Injection: Instead of hardcoding strategy creation, inject strategies through constructors or setters
Implement Strategy Factory: Create a factory to manage strategy creation and selection logic
Consider Strategy Caching: For expensive strategy creation, implement caching mechanisms
Add Validation: Always validate strategy inputs and handle edge cases gracefully
Document Strategy Contracts: Clearly define what each strategy expects and guarantees

// Strategy Factory Example
public class DiscountStrategyFactory {
    private static final Map<CustomerType, DiscountStrategy> strategies = 
        new EnumMap<>(CustomerType.class);
    
    static {
        strategies.put(CustomerType.REGULAR, new RegularCustomerDiscount());
        strategies.put(CustomerType.PREMIUM, new PremiumCustomerDiscount());
        strategies.put(CustomerType.VIP, new VIPCustomerDiscount());
    }
    
    public static DiscountStrategy getStrategy(CustomerType customerType) {
        DiscountStrategy strategy = strategies.get(customerType);
        if (strategy == null) {
            throw new IllegalArgumentException("No strategy for customer type: " + customerType);
        }
        return strategy;
    }
    
    public static DiscountStrategy getSeasonalStrategy(Season season) {
        return switch (season) {
            case SUMMER -> new SeasonalDiscount(0.10, "Summer Sale");
            case WINTER -> new SeasonalDiscount(0.20, "Winter Clearance");
            case BLACK_FRIDAY -> new SeasonalDiscount(0.35, "Black Friday");
            default -> new NoDiscount();
        };
    }
}

Common Pitfalls to Avoid:

Strategy Explosion: Don't create too many small strategies; group related logic when possible
Ignoring Null Strategies: Always provide a default/null object strategy to avoid null pointer exceptions
State Management Issues: Keep strategies stateless when possible; if state is needed, manage it carefully
Overengineering: Don't use Strategy pattern for simple, static logic that won't change
Missing Validation: Always validate strategy parameters and provide meaningful error messages

Thread Safety Considerations:

// Thread-safe strategy implementation
public class ThreadSafeDiscountStrategy implements DiscountStrategy {
    private final AtomicLong discountCounter = new AtomicLong(0);
    private final double discountRate;
    
    public ThreadSafeDiscountStrategy(double discountRate) {
        this.discountRate = discountRate;
    }
    
    @Override
    public double calculateDiscount(double originalPrice) {
        discountCounter.incrementAndGet(); // Track usage atomically
        return originalPrice * discountRate;
    }
    
    @Override
    public String getDiscountDescription() {
        return String.format("Thread-safe discount: %.1f%% (used %d times)", 
            discountRate * 100, discountCounter.get());
    }
    
    public long getUsageCount() {
        return discountCounter.get();
    }
}

Integration with Modern Java Features

Modern Java versions provide excellent support for implementing Strategy patterns more elegantly:

Using Functional Interfaces (Java 8+):

// Functional strategy interface
@FunctionalInterface
public interface DiscountCalculator {
    double calculate(double originalPrice);
}

// Lambda-based strategy usage
public class ModernShoppingCart {
    private DiscountCalculator discountCalculator = price -> 0; // Default: no discount
    
    public void setDiscountCalculator(DiscountCalculator calculator) {
        this.discountCalculator = calculator != null ? calculator : price -> 0;
    }
    
    public double calculateTotal(List<Item> items) {
        double subtotal = items.stream()
            .mapToDouble(Item::getPrice)
            .sum();
        return subtotal - discountCalculator.calculate(subtotal);
    }
    
    // Usage examples
    public static void demonstrateModernApproach() {
        ModernShoppingCart cart = new ModernShoppingCart();
        List<Item> items = Arrays.asList(
            new Item("Laptop", 1000),
            new Item("Mouse", 50)
        );
        
        // Lambda strategies
        cart.setDiscountCalculator(price -> price * 0.1); // 10% discount
        System.out.println("10% discount total: " + cart.calculateTotal(items));
        
        // Method reference strategies
        cart.setDiscountCalculator(ModernShoppingCart::studentDiscount);
        System.out.println("Student discount total: " + cart.calculateTotal(items));
        
        // Complex lambda with conditions
        cart.setDiscountCalculator(price -> 
            price > 500 ? price * 0.15 : price * 0.05);
        System.out.println("Tiered discount total: " + cart.calculateTotal(items));
    }
    
    private static double studentDiscount(double price) {
        return price * 0.20; // 20% student discount
    }
}

Strategy Pattern with Records (Java 14+):

// Using records for strategy configuration
public record DiscountConfig(double rate, String description, Predicate<Double> condition) {
    public double applyDiscount(double price) {
        return condition.test(price) ? price * rate : 0;
    }
}

// Strategy factory using records
public class RecordBasedStrategyFactory {
    private static final List<DiscountConfig> DISCOUNT_CONFIGS = List.of(
        new DiscountConfig(0.05, "Small order discount", price -> price < 100),
        new DiscountConfig(0.10, "Medium order discount", price -> price >= 100 && price < 500),
        new DiscountConfig(0.15, "Large order discount", price -> price >= 500)
    );
    
    public static double calculateBestDiscount(double price) {
        return DISCOUNT_CONFIGS.stream()
            .mapToDouble(config -> config.applyDiscount(price))
            .max()
            .orElse(0);
    }
}

The Strategy Design Pattern remains one of the most practical and widely-used behavioral patterns in enterprise Java development. When building applications that require flexible business logic, payment processing, or algorithmic variations, implementing this pattern correctly will save significant maintenance time and provide the scalability needed for growing applications. For applications running on robust infrastructure like VPS hosting or dedicated servers, the Strategy pattern's flexibility becomes even more valuable when handling varying loads and different client requirements.

For further reading on Java design patterns and best practices, consult the official Oracle Java tutorials and the comprehensive design patterns guide at Refactoring Guru.

This article incorporates information and material from various online sources. We acknowledge and appreciate the work of all original authors, publishers, and websites. While every effort has been made to appropriately credit the source material, any unintentional oversight or omission does not constitute a copyright infringement. All trademarks, logos, and images mentioned are the property of their respective owners. If you believe that any content used in this article infringes upon your copyright, please contact us immediately for review and prompt action.

This article is intended for informational and educational purposes only and does not infringe on the rights of the copyright owners. If any copyrighted material has been used without proper credit or in violation of copyright laws, it is unintentional and we will rectify it promptly upon notification. Please note that the republishing, redistribution, or reproduction of part or all of the contents in any form is prohibited without express written permission from the author and website owner. For permissions or further inquiries, please contact us.