The Strategy pattern addresses a fundamental challenge in software architecture: managing interchangeable algorithms without tightly coupling execution logic to the objects that invoke them. By prioritizing object composition over rigid inheritance trees, this behavioral design technique enables systems to alter their operational behavior at runtime through dynamic algorithm swaping.

Structural Architecture

• Algorithm Contract (Interface): Defines the abstract method signature shared across all supported variations.
• Concrete Implementations**: Specialized classes that realize the contract by embedding distinct computational logic.
• Execution Environment (Context): Holds a reference to the active algorithm and delegates processing tasks. It provides APIs to swap the underlying strategy without disrupting dependent modules.

Core Implementation

The following Java implementation replaces traditional arithmetic operations with a dynamic pricing engine, demonstrating how business rules can be modularized and tested independently.

// 1. Establish the algorithm contract
public interface PricingRule {
    double calculateCost(double baseAmount);
}

// 2. Implement concrete rule variations
public class StandardPricing implements PricingRule {
    @Override
    public double calculateCost(double baseAmount) {
        return baseAmount;
    }
}

public class DiscountPricing implements PricingRule {
    private final double reductionPercent;

    public DiscountPricing(double percent) {
        this.reductionPercent = percent;
    }

    @Override
    public double calculateCost(double baseAmount) {
        return baseAmount * (1 - reductionPercent / 100.0);
    }
}

public class RushPricing implements PricingRule {
    @Override
    public double calculateCost(double baseAmount) {
        return baseAmount * 1.75; // Expedited handling surcharge
    }
}

The environment class functions as the client-facing facade. It delegates calculations without exposing internal branching logic.

// 3. Construct the execution environment
public class CheckoutProcessor {
    private PricingRule activeRule;

    public CheckoutProcessor(PricingRule initialRule) {
        setActiveRule(initialRule);
    }

    public void setActiveRule(PricingRule rule) {
        this.activeRule = rule;
    }

    public double executeCheckout(double subtotal) {
        if (activeRule == null) {
            throw new IllegalStateException("Pricing strategy not initialized.");
        }
        return activeRule.calculateCost(subtotal);
    }
}

Consumers instantiate the processor with the desired rule and invoke transactions without knowledge of the underlying mathematics.

// 4. Client interaction
public class SystemInit {
    public static void main(String[] args) {
        CheckoutProcessor basket = new CheckoutProcessor(new StandardPricing());
        
        System.out.println("Base Price: " + basket.executeCheckout(120.0));
        
        basket.setActiveRule(new DiscountPricing(15.0));
        System.out.println("Promo Applied: " + basket.executeCheckout(120.0));
        
        basket.setActiveRule(new RushPricing());
        System.out.println("Express Rate: " + basket.executeCheckout(120.0));
    }
}

Terminal Output:

Base Price: 120.0
Promo Applied: 102.0
Express Rate: 210.0

Advantages and Trade-offs

Technical Benefits

• Enforces Open/Closed Principal: New algorithmic variants can be integrated by introducing classes rather than patching existing control flow.
• Removes Conditional Clutter: Eliminates deeply nested if-statements or exhaustive switch-cases that complicate maintenance.
• Isolated Validation: Each strategy operates as an independent unit, simplifying mocking and boundary testing.

Potential Limitations

• Nomenclature Proliferation: Minor logical differences often require dedicated classes, expanding the package footprint.
• Client Dependency Burden: Instantiation code must comprehend available strategy constructors and behavioral contracts prior to runtime assembly.

Production Scenario: Multi-Format Data Export

Enterprise reporting systems frequently require simultaneous support for diverse serialization standards. Applying this pattern decouples the document pipeline from file-format specifics.

public interface SerializationStrategy {
    String encode(java.util.Map<String, Object> payload);
}

public class XmlEncoder implements SerializationStrategy {
    @Override
    public String encode(java.util.Map<String, Object> payload) {
        StringBuilder builder = new StringBuilder("<root>");
        payload.forEach((k, v) -> builder.append("<item key='").append(k).append("'>")
                .append(v).append("</item>"));
        builder.append("</root>");
        return builder.toString();
    }
}

public class JsonEncoder implements SerializationStrategy {
    @Override
    public String encode(java.util.Map<String, Object> payload) {
        return "{\"" + String.join("\",\"", 
                payload.entrySet().stream().map(e -> e.getKey() + ":" + e.getValue())
                .toArray(String[]::new)) + "\"}";
    }
}

public class BinaryEncoder implements SerializationStrategy {
    @Override
    public String encode(java.util.Map<String, Object> payload) {
        return "[BLOB_STREAM_COMPRESSED_" + payload.size() + "_FIELDS]";
    }
}

The export manager orchestrates format selection and routes payload encoding requests.

public class DataExporter {
    private SerializationStrategy encoder;

    public DataExporter(SerializationStrategy format) {
        this.encoder = format;
    }

    public void updateEncodingStrategy(SerializationStrategy newFormat) {
        this.encoder = newFormat;
    }

    public void dispatch(java.util.Map<String, Object> record) {
        System.out.println(encoder.encode(record));
    }
}

public class PipelineRunner {
    public static void main(String[] args) {
        var exporter = new DataExporter(new XmlEncoder());
        var shipmentRecord = java.util.Map.of("order_id", "X99", "carrier", "FedEx");
        
        exporter.dispatch(shipmentRecord);
        
        exporter.updateEncodingStrategy(new JsonEncoder());
        exporter.dispatch(shipmentRecord);
        
        exporter.updateEncodingStrategy(new BinaryEncoder());
        exporter.dispatch(shipmentRecord);
    }
}

Console Trace:

<root><item key='carrier'>FedEx</item><item key='order_id'>X99</item></root>
{"carrier:FedEx,order_id:X99"}
[BLOB_STREAM_COMPRESSED_2_FIELDS]