💳 Implementing Strategy Design Pattern in a Shopping Cart System [Java LLD + Balance Check]

In this blog, we’ll explore how to use the Strategy Design Pattern to build a clean, extensible payment system for an online shopping cart. We'll also simulate balance checking to reject payments if funds are insufficient.

---

🚀 What We'll Build

• A ShoppingCart that can accept various payment methods
• Dynamic switching between strategies like CreditCard and PayPal
• Balance validation for each payment type
• Loose coupling between business logic and payment algorithms

---

🧠 Why Strategy Pattern?

The Strategy Pattern enables:

• Defining multiple payment algorithms independently
• Selecting an algorithm at runtime
• Extending behavior without modifying core logic (Open/Closed Principle)

---

🔧 Core Components

Component	Responsibility
PaymentStrategy	Interface for all payment types
CreditCard, Paypal	Implements actual payment behavior
Item	Represents a purchasable item
ShopingCart	Holds items and delegates payment logic
Test	Acts as the client to test different strategies

---

📦 Project Structure

📁 Strategy/
├── CreditCard.java
├── Paypal.java
├── Item.java
├── PaymentStrategy.java
├── ShopingCart.java
└── Test.java

---

📐 UML Diagram

               +-----------------------+
               |   PaymentStrategy     |  <<interface>>
               +-----------------------+
               | +pay(int)             |
               +-----------------------+
                  ▲               ▲
   +----------------------+   +----------------------+
   |    CreditCard        |   |       Paypal         |
   +----------------------+   +----------------------+
   | +pay(int)            |   | +pay(int)            |
   +----------------------+   +----------------------+

               +---------------------+
               |    ShopingCart      |
               +---------------------+
               | +addItem()          |
               | +pay(PaymentStrategy)|
               +---------------------+

---

🧾 Full Java Implementation with Balance Check

✅ 1. PaymentStrategy.java

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

---

✅ 2. CreditCard.java

public class CreditCard implements PaymentStrategy {
    private final String name;
    private final String cardNumber;
    private final String cvv;
    private int balance;

    public CreditCard(String name, String cardNumber, String cvv, int balance) {
        this.name = name;
        this.cardNumber = cardNumber;
        this.cvv = cvv;
        this.balance = balance;
    }

    @Override
    public void pay(int amount) {
        if (hasSufficientBalance(amount)) {
            balance -= amount;
            System.out.println("💳 Paid ₹" + amount + " using Credit Card [Holder: " + name + "]");
        } else {
            System.out.println("❌ Credit Card payment failed: Insufficient balance.");
        }
    }

    @Override
    public boolean hasSufficientBalance(int amount) {
        return balance >= amount;
    }
}

---

✅ 3. Paypal.java

public class Paypal implements PaymentStrategy {
    private final String email;
    private final String password;
    private int balance;

    public Paypal(String email, String password, int balance) {
        this.email = email;
        this.password = password;
        this.balance = balance;
    }

    @Override
    public void pay(int amount) {
        if (hasSufficientBalance(amount)) {
            balance -= amount;
            System.out.println("🌐 Paid ₹" + amount + " using PayPal [Email: " + email + "]");
        } else {
            System.out.println("❌ PayPal payment failed: Insufficient balance.");
        }
    }

    @Override
    public boolean hasSufficientBalance(int amount) {
        return balance >= amount;
    }
}

---

✅ 4. Item.java

public class Item {
    private final String name;
    private final int price;

    public Item(String name, int price) {
        this.name = name;
        this.price = price;
    }

    public int getPrice() {
        return price;
    }

    public String getName() {
        return name;
    }
}

---

✅ 5. ShopingCart.java

import java.util.ArrayList;
import java.util.List;

public class ShopingCart {
    private final List<Item> items = new ArrayList<>();

    public void addItem(Item item) {
        items.add(item);
    }

    public int calculateTotal() {
        return items.stream().mapToInt(Item::getPrice).sum();
    }

    public void pay(PaymentStrategy strategy) {
        int amount = calculateTotal();
        if (strategy.hasSufficientBalance(amount)) {
            strategy.pay(amount);
        } else {
            System.out.println("❗ Transaction declined due to insufficient balance.");
        }
    }
}

---

✅ 6. Test.java

public class Test {
    public static void main(String[] args) {
        ShopingCart cart = new ShopingCart();
        cart.addItem(new Item("Laptop", 40000));
        cart.addItem(new Item("Keyboard", 5000));

        PaymentStrategy creditCard = new CreditCard("Alice", "1234-5678-9012", "999", 45000);
        PaymentStrategy paypal = new Paypal("[e-mail]", "bob@123", 30000);

        // Try Credit Card
        cart.pay(creditCard); // Success

        // Try PayPal
        cart.pay(paypal);     // Fail due to insufficient balance
    }
}

---

🧪 Sample Output

💳 Paid ₹45000 using Credit Card [Holder: Alice]
❌ PayPal payment failed: Insufficient balance.

---

✅ Benefits of Strategy Pattern

Advantage	Explanation
✅ Decouples behavior	Payment logic is separate from business logic
✅ Runtime flexibility	Switch strategies without code change
✅ Easy to extend	Add new payment types without breaking anything
✅ Testable	Each strategy can be independently tested

---

⚠️ Gotchas

• You may need a Strategy Factory if many implementations exist.
• Always validate strategy readiness (e.g., balance) before execution.
• Consider using Spring's @Component injection for runtime wiring.

---

🧠 Interview Tip

If asked to design a payment system, checkout flow, or modular transaction handler, the Strategy Pattern is a great fit.
Mention how this approach avoids if-else chains and follows OCP (Open/Closed Principle).

---