Strategy Pattern

The Strategy Pattern is a Behavioral Design Pattern that allows you to define multiple algorithms (strategies) and switch between them dynamically at runtime without changing the main code.

It helps follow the Open/Closed Principle:

• Open for extension

• Closed for modification

---

Real-Life Example

Think about a payment system:

A user can pay using:

• Credit Card

• PayPal

• Stripe

• Mobile Banking

Instead of writing large if-else conditions, we create separate payment strategies.

---

Problem Without Strategy Pattern

class PaymentService {

    public function pay($method, $amount) {

        if($method == 'paypal') {
            return "Paid $amount using PayPal";
        }

        if($method == 'stripe') {
            return "Paid $amount using Stripe";
        }

        if($method == 'bkash') {
            return "Paid $amount using bKash";
        }
    }
}

Problems

❌ Huge if-else blocks ❌ Hard to maintain ❌ Difficult to add new payment methods ❌ Violates Open/Closed Principle

---

Strategy Pattern Solution

Step 1: Create Strategy Interface

interface PaymentStrategy
{
    public function pay($amount);
}

This interface defines a common behavior for all payment methods.

---

Step 2: Create Concrete Strategies

PayPal Strategy

class PaypalPayment implements PaymentStrategy
{
    public function pay($amount)
    {
        return "Paid {$amount} using PayPal";
    }
}

---

Stripe Strategy

class StripePayment implements PaymentStrategy
{
    public function pay($amount)
    {
        return "Paid {$amount} using Stripe";
    }
}

---

bKash Strategy

class BkashPayment implements PaymentStrategy
{
    public function pay($amount)
    {
        return "Paid {$amount} using bKash";
    }
}

---

Step 3: Create Context Class

The Context class uses a strategy object.

class PaymentContext
{
    protected $paymentStrategy;

    public function __construct(PaymentStrategy $paymentStrategy)
    {
        $this->paymentStrategy = $paymentStrategy;
    }

    public function executePayment($amount)
    {
        return $this->paymentStrategy->pay($amount);
    }
}

---

Step 4: Use Strategy Dynamically

Pay with PayPal

$payment = new PaymentContext(
    new PaypalPayment()
);

echo $payment->executePayment(1000);

Output

Paid 1000 using PayPal

---

Pay with Stripe

$payment = new PaymentContext(
    new StripePayment()
);

echo $payment->executePayment(2000);

---

Pay with bKash

$payment = new PaymentContext(
    new BkashPayment()
);

echo $payment->executePayment(500);

---

Full Working Example

<?php

interface PaymentStrategy
{
    public function pay($amount);
}

class PaypalPayment implements PaymentStrategy
{
    public function pay($amount)
    {
        return "Paid {$amount} using PayPal";
    }
}

class StripePayment implements PaymentStrategy
{
    public function pay($amount)
    {
        return "Paid {$amount} using Stripe";
    }
}

class BkashPayment implements PaymentStrategy
{
    public function pay($amount)
    {
        return "Paid {$amount} using bKash";
    }
}

class PaymentContext
{
    protected $paymentStrategy;

    public function __construct(PaymentStrategy $paymentStrategy)
    {
        $this->paymentStrategy = $paymentStrategy;
    }

    public function executePayment($amount)
    {
        return $this->paymentStrategy->pay($amount);
    }
}

$payment = new PaymentContext(
    new PaypalPayment()
);

echo $payment->executePayment(1000);

---

UML Structure

        PaymentStrategy
              ▲
      -------------------
      |        |        |
 Paypal   Stripe   bKash

              ▲
       PaymentContext

---

Advantages

✅ Easy to Add New Strategy

Add new payment methods without modifying existing code.

class NagadPayment implements PaymentStrategy
{
    public function pay($amount)
    {
        return "Paid {$amount} using Nagad";
    }
}

---

✅ Cleaner Code

Avoids huge conditional statements.

---

✅ Follows SOLID Principles

Especially:

• Open/Closed Principle

• Single Responsibility Principle

---

✅ Runtime Flexibility

Strategies can change dynamically.

$strategy = new StripePayment();

if($country == 'BD') {
    $strategy = new BkashPayment();
}

---

Real Laravel Examples

Feature	Strategy Used
Cache Drivers	Redis/File/Database
Payment Gateways	Stripe/PayPal
Notification Channels	Mail/SMS/Slack
Queue Drivers	Redis/SQS/Database
Authentication Guards	Session/API

---

Another Example: Sorting Strategy

interface SortStrategy
{
    public function sort(array $data);
}

class BubbleSort implements SortStrategy
{
    public function sort(array $data)
    {
        sort($data);
        return $data;
    }
}

class ReverseSort implements SortStrategy
{
    public function sort(array $data)
    {
        rsort($data);
        return $data;
    }
}

---

When to Use Strategy Pattern

Use Strategy Pattern when:

✅ Multiple algorithms exist ✅ You want to switch behavior dynamically ✅ Large if-else blocks exist ✅ Logic changes frequently ✅ Need clean and scalable architecture

---

When NOT to Use

❌ Only one algorithm exists ❌ Logic is very simple ❌ Too many small classes become unnecessary

---

Bridge Pattern vs Strategy Pattern

Both Bridge and Strategy patterns use composition instead of inheritance, so many developers confuse them. But their purposes are completely different.

---

Main Difference

Pattern	Purpose
Bridge Pattern	Separates abstraction from implementation
Strategy Pattern	Changes behavior/algorithm dynamically

---

Simple Understanding

Bridge Pattern

Used when you have:

• Multiple abstractions

• Multiple implementations

And you want to avoid class explosion.

Focus:

👉 Structure and scalability

---

Strategy Pattern

Used when you have:

• Multiple algorithms or behaviors

And you want to switch them dynamically.

Focus:

👉 Behavior selection

---

Real-Life Analogy

Bridge Pattern Example

Think of:

• Remote Controls

• TVs

Different remotes can work with different TVs.

Remote → Samsung TV
Remote → Sony TV
Advanced Remote → Samsung TV
Advanced Remote → Sony TV

Bridge separates:

• Abstraction = Remote

• Implementation = TV

---

Strategy Pattern Example

Think of payment methods:

• PayPal

• Stripe

• bKash

You choose one strategy dynamically.

Checkout → PayPal
Checkout → Stripe
Checkout → bKash

---

1. Strategy Pattern Example

Goal

Change payment behavior dynamically.

---

Strategy Interface

interface PaymentStrategy
{
    public function pay($amount);
}

---

Concrete Strategies

class PaypalPayment implements PaymentStrategy
{
    public function pay($amount)
    {
        return "Paid via PayPal";
    }
}

class StripePayment implements PaymentStrategy
{
    public function pay($amount)
    {
        return "Paid via Stripe";
    }
}

---

Context Class

class PaymentContext
{
    protected $strategy;

    public function __construct(PaymentStrategy $strategy)
    {
        $this->strategy = $strategy;
    }

    public function execute($amount)
    {
        return $this->strategy->pay($amount);
    }
}

---

Usage

$payment = new PaymentContext(
    new PaypalPayment()
);

echo $payment->execute(1000);

---

Strategy Pattern Structure

Context → Strategy Interface → Concrete Strategies

---

Strategy Pattern Purpose

✅ Swap algorithms ✅ Dynamic behavior ✅ Remove if-else conditions ✅ Encapsulate business rules

---

2. Bridge Pattern Example

Goal

Separate abstraction from implementation.

---

Problem Without Bridge

SamsungBasicRemote
SamsungAdvancedRemote
SonyBasicRemote
SonyAdvancedRemote
LGAdvancedRemote
...

Huge class explosion.

---

Bridge Solution

---

Implementation Interface

interface TV
{
    public function on();
    public function off();
}

---

Concrete Implementations

class SamsungTV implements TV
{
    public function on()
    {
        return "Samsung TV ON";
    }

    public function off()
    {
        return "Samsung TV OFF";
    }
}

---

class SonyTV implements TV
{
    public function on()
    {
        return "Sony TV ON";
    }

    public function off()
    {
        return "Sony TV OFF";
    }
}

---

Abstraction Class

class RemoteControl
{
    protected $tv;

    public function __construct(TV $tv)
    {
        $this->tv = $tv;
    }

    public function turnOn()
    {
        return $this->tv->on();
    }
}

---

Refined Abstraction

class AdvancedRemote extends RemoteControl
{
    public function mute()
    {
        return "TV Muted";
    }
}

---

Usage

$remote = new AdvancedRemote(
    new SamsungTV()
);

echo $remote->turnOn();

---

Bridge Pattern Structure

Abstraction → Implementation Interface → Concrete Implementations

---

Bridge Pattern Purpose

✅ Avoid class explosion ✅ Independent scalability ✅ Separate abstraction from implementation ✅ Better flexibility

---

Key Differences

Feature	Strategy	Bridge
Type	Behavioral Pattern	Structural Pattern
Purpose	Change behavior	Separate abstraction & implementation
Focus	Algorithms	Structure
Runtime Change	Yes	Usually not primary goal
Composition Used For	Behavior	Architecture
Main Problem Solved	Large conditional logic	Class explosion
Example	Payment methods	Remote + TV

---

Easy Interview Answer

Strategy Pattern

Strategy Pattern changes object behavior dynamically by selecting different algorithms at runtime.

---

Bridge Pattern

Bridge Pattern separates abstraction from implementation so both can evolve independently.