Strategy Pattern in Java: Stop Hardcoding Behaviour and Start Swapping It

// ❌ THE ANTI-PATTERN — what NOT to do
// Every new payment method forces us to edit this class.
// One typo here can break ALL payment methods at once.
public class NaiveOrderProcessor {

    // The payment type is passed as a raw string — brittle and error-prone
    public void processPayment(String paymentType, double amount) {

        if (paymentType.equals("CREDIT_CARD")) {
            // Credit card processing logic
            System.out.println("Charging $" + amount + " to credit card via Stripe API");
            System.out.println("Applying 1.5% transaction fee");

        } else if (paymentType.equals("PAYPAL")) {
            // PayPal processing logic — completely different flow
            System.out.println("Redirecting to PayPal gateway for $" + amount);
            System.out.println("Applying 2.9% PayPal fee");

        } else if (paymentType.equals("CRYPTO")) {
            // Crypto logic — yet another completely different flow
            System.out.println("Opening crypto wallet for $" + amount + " in BTC");
            System.out.println("Waiting for blockchain confirmation...");

        } else {
            throw new IllegalArgumentException("Unknown payment type: " + paymentType);
        }
    }

    public static void main(String[] args) {
        NaiveOrderProcessor processor = new NaiveOrderProcessor();
        processor.processPayment("CREDIT_CARD", 99.99);
        processor.processPayment("PAYPAL", 49.50);
        // Adding a new payment type means coming back HERE and adding another else-if
    }
}

// ✅ THE STRATEGY PATTERN — clean, extensible, and testable

// ── STEP 1: Define the Strategy interface ──────────────────────────────────
// Every payment method MUST implement this contract.
// The Context (OrderProcessor) only ever talks to this interface.
interface PaymentStrategy {
    void pay(double amount);          // the algorithm hook
    double calculateFee(double amount); // bonus: fees are also encapsulated per strategy
}

// ── STEP 2: Concrete Strategy A — Credit Card ──────────────────────────────
class CreditCardPaymentStrategy implements PaymentStrategy {

    private final String cardHolderName;
    private final String maskedCardNumber; // store only last 4 digits for safety

    public CreditCardPaymentStrategy(String cardHolderName, String maskedCardNumber) {
        this.cardHolderName = cardHolderName;
        this.maskedCardNumber = maskedCardNumber;
    }

    @Override
    public void pay(double amount) {
        double fee = calculateFee(amount);
        double totalCharged = amount + fee;
        // This class ONLY knows about credit card logic — nothing else
        System.out.printf("[Credit Card] Charging $%.2f (+ $%.2f fee = $%.2f total) "
                + "to card ending in %s for %s%n",
                amount, fee, totalCharged, maskedCardNumber, cardHolderName);
    }

    @Override
    public double calculateFee(double amount) {
        return amount * 0.015; // Stripe charges 1.5%
    }
}

// ── STEP 3: Concrete Strategy B — PayPal ───────────────────────────────────
class PayPalPaymentStrategy implements PaymentStrategy {

    private final String paypalEmail;

    public PayPalPaymentStrategy(String paypalEmail) {
        this.paypalEmail = paypalEmail;
    }

    @Override
    public void pay(double amount) {
        double fee = calculateFee(amount);
        double totalCharged = amount + fee;
        System.out.printf("[PayPal] Redirecting %s to PayPal for $%.2f "
                + "(+ $%.2f PayPal fee = $%.2f total)%n",
                paypalEmail, amount, fee, totalCharged);
    }

    @Override
    public double calculateFee(double amount) {
        return amount * 0.029; // PayPal charges 2.9%
    }
}

// ── STEP 4: Concrete Strategy C — Crypto ───────────────────────────────────
class CryptoPaymentStrategy implements PaymentStrategy {

    private final String walletAddress;

    public CryptoPaymentStrategy(String walletAddress) {
        this.walletAddress = walletAddress;
    }

    @Override
    public void pay(double amount) {
        double fee = calculateFee(amount);
        // Crypto has network fees but we pass savings on to the user
        System.out.printf("[Crypto] Sending $%.2f (network fee: $%.2f) "
                + "to wallet %s — awaiting blockchain confirmation%n",
                amount, fee, walletAddress);
    }

    @Override
    public double calculateFee(double amount) {
        return 0.50; // flat $0.50 network fee regardless of amount
    }
}

// ── STEP 5: The Context — OrderProcessor ───────────────────────────────────
// This class has NO idea which payment method is being used.
// It just calls pay() and the strategy handles everything.
class OrderProcessor {

    // Holds a reference to the interface — NOT a concrete class
    private PaymentStrategy paymentStrategy;

    // Strategy is injected via the constructor (constructor injection)
    public OrderProcessor(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    // You can also swap the strategy at runtime — powerful for multi-step checkouts
    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout(double orderTotal) {
        System.out.println("\n=== Processing Order: $" + orderTotal + " ===");
        paymentStrategy.pay(orderTotal); // delegate — don't care HOW it's done
        System.out.println("Order confirmed. Receipt sent.");
    }
}

// ── STEP 6: Wire it all together ───────────────────────────────────────────
public class StrategyPatternPayment {

    public static void main(String[] args) {

        // Customer A pays by credit card
        PaymentStrategy creditCard = new CreditCardPaymentStrategy("Alice Johnson", "4242");
        OrderProcessor aliceCheckout = new OrderProcessor(creditCard);
        aliceCheckout.checkout(120.00);

        // Customer B pays via PayPal
        PaymentStrategy paypal = new PayPalPaymentStrategy("bob@example.com");
        OrderProcessor bobCheckout = new OrderProcessor(paypal);
        bobCheckout.checkout(75.00);

        // Customer C switches from PayPal to crypto mid-session (runtime swap!)
        PaymentStrategy crypto = new CryptoPaymentStrategy("0xABCD1234EF");
        bobCheckout.setPaymentStrategy(crypto); // hot-swap the strategy
        bobCheckout.checkout(75.00);
    }
}

// BONUS: In Java 8+, if your Strategy interface has ONE method,
// you can use lambdas as lightweight strategies — no boilerplate class needed.
// This is perfect for simple, one-off strategies defined at the call site.

@FunctionalInterface // marks this as safe to use with lambdas
interface DiscountStrategy {
    double apply(double originalPrice);
}

class PricingEngine {

    private DiscountStrategy discountStrategy;

    public PricingEngine(DiscountStrategy discountStrategy) {
        this.discountStrategy = discountStrategy;
    }

    public double calculateFinalPrice(double originalPrice) {
        return discountStrategy.apply(originalPrice);
    }
}

public class StrategyWithLambda {

    public static void main(String[] args) {

        // Strategy 1: 10% off for loyal customers — defined inline as a lambda
        PricingEngine loyalCustomerPricing = new PricingEngine(
                price -> price * 0.90  // the lambda IS the strategy
        );

        // Strategy 2: Flat $5 off for newsletter subscribers
        PricingEngine newsletterPricing = new PricingEngine(
                price -> Math.max(0, price - 5.00) // never go below $0
        );

        // Strategy 3: No discount for regular customers
        PricingEngine regularPricing = new PricingEngine(
                price -> price // identity — no change
        );

        double basePrice = 45.00;

        System.out.printf("Base price:               $%.2f%n", basePrice);
        System.out.printf("Loyal customer price:     $%.2f%n", loyalCustomerPricing.calculateFinalPrice(basePrice));
        System.out.printf("Newsletter subscriber:    $%.2f%n", newsletterPricing.calculateFinalPrice(basePrice));
        System.out.printf("Regular customer price:   $%.2f%n", regularPricing.calculateFinalPrice(basePrice));
    }
}