Blueprint

The refactored code implements the Strategy Design Pattern, a Behavioural pattern. It turns each behavior or algorithm into its own object. The main class, called the context, can then swap one for another.

1. How This Solves the Earlier Problems

The if-else branches are gone. Instead, the service holds a strategy object (composition, one object holding another) and hands the work to it (delegation). This fixes the problems from the Before code.

Problem in Old Approach	How Strategy Pattern Solves It
Violation of Open/Closed Principle (OCP)	To add a strategy (e.g., `VipRiderStrategy`), write a new class that implements the `MatchingStrategy` interface. The existing service code stays unchanged.
Code Becomes Messy	The nested `if-else` or `switch` logic is gone. Each branch now lives in its own strategy class, and the service calls it.
Difficult to Test or Reuse	Each strategy is a small class on its own. You can test it alone, or reuse the proximity or queue logic in other modules (like a delivery service).
No Separation of Concerns	`RideMatchingService` only decides when to run the matching. The matching math lives in the strategy classes.

2. Suitable Scenarios for Strategy Pattern

Use the Strategy Pattern in these situations:

Multiple Interchangeable Algorithms: When there are different ways to do one operation (e.g., sorting algorithms, payment gateways, or compression formats) and you pick one depending on the situation.
Compliance with Open/Closed Principle (OCP): When new variants will keep arriving and you want to protect working code from regressions.
Elimination of Conditionals: When large if-else or switch blocks pick a behavior. Strategy replaces them with classes. The same call, match, runs different code depending on the object (polymorphism).
Behavior-Specific Unit Testing: When you want to test one calculation alone, without setting up the whole service.
Runtime Behavior Selection: When a class must change its behavior while running, based on things like the user's tier or system settings.

3. Structural Breakdown

Component	Responsibility
Strategy Interface (`MatchingStrategy`)	The one method signature (name and inputs) shared by all strategies.
Concrete Strategies (`NearestDriverStrategy`, etc.)	Each one holds the steps of one algorithm.
Context (`RideMatchingService`)	Holds a strategy object and passes the work to it.

4. Summary of the "Plug-and-Play" Architecture

Think of the Strategy Pattern as an Engine and Tires combination. The car (Context) stays the same, but you can swap the tires (Strategies) between street tires, winter snow tires and track racing tires, depending on the weather. The car does not change how it drives. It leaves the grip to whichever tires are fitted.

In this topic

After code1 file

After/Main.java122 linesGitHub

1package DesignPatterns.BehaviouralPatterns.StrategyPattern.After;2// ============================================================================3// 1. STRATEGY INTERFACE4// ============================================================================5/**6 * Defines the unified contract for all ride-matching algorithms.7 * The Context class will interact only with this interface, making it8 * decoupled from specific algorithm implementations.9 */10interface MatchingStrategy {11    void match(String riderLocation);12}1314// ============================================================================15// 2. CONCRETE STRATEGIES16// ============================================================================17/**18 * Encapsulates standard distance-based proximity calculations.19 */20class NearestDriverStrategy implements MatchingStrategy {2122    @Override23    public void match(String riderLocation) {24        System.out.println(25            "Matching with the nearest available driver to " + riderLocation26        );27        // Isolated algorithmic logic goes here28    }29}3031/**32 * Encapsulates First-In, First-Out (FIFO) queue logic specialized for airport hubs.33 */34class AirportQueueStrategy implements MatchingStrategy {3536    @Override37    public void match(String riderLocation) {38        System.out.println(39            "Matching using FIFO airport queue for " + riderLocation40        );41        // Isolated algorithmic logic goes here42    }43}4445/**46 * Encapsulates peak-demand, surge pricing priority distribution algorithms.47 */48class SurgePriorityStrategy implements MatchingStrategy {4950    @Override51    public void match(String riderLocation) {52        System.out.println(53            "Matching rider using surge pricing priority near " + riderLocation54        );55        // Isolated algorithmic logic goes here56    }57}5859// ============================================================================60// 3. CONTEXT CLASS61// ============================================================================62/**63 * Serves as the orchestration engine. It does not know how to compute64 * matching coordinates; it only knows *when* to execute the strategy.65 */66class RideMatchingService {6768    // COMPOSITION OVER INHERITANCE: Maintains a reference to the strategy interface69    private MatchingStrategy strategy;7071    /**72     * Constructor Injection: Forces the client to provide a valid baseline behavior73     * upon instantiation, avoiding null pointer issues.74     */75    public RideMatchingService(MatchingStrategy strategy) {76        this.strategy = strategy;77    }7879    /**80     * Setter Injection: Provides RUNTIME FLEXIBILITY.81     * Allows the application to dynamically shift algorithms on the fly82     * without needing to reconstruct the service object.83     */84    public void setStrategy(MatchingStrategy strategy) {85        this.strategy = strategy;86    }8788    /**89     * DELEGATION: Instead of running an if-else check, the context cleanly90     * delegates the task directly to whichever strategy is currently active.91     */92    public void matchRider(String location) {93        strategy.match(location);94    }95}9697// ============================================================================98// 4. CLIENT CODE99// ============================================================================100public class Main {101102    public static void main(String[] args) {103        // Scenario A: Initializing service with a localized Airport state104        RideMatchingService rideMatchingService = new RideMatchingService(105            new AirportQueueStrategy()106        );107        rideMatchingService.matchRider("Terminal 1");108109        System.out.println("------------------------------------------------");110111        // Scenario B: Initializing with a default strategy and changing behaviors dynamically112        RideMatchingService rideMatchingService2 = new RideMatchingService(113            new NearestDriverStrategy()114        );115        rideMatchingService2.matchRider("Downtown");116117        // Runtime modification: Switching behavioral execution instantly118        rideMatchingService2.setStrategy(new SurgePriorityStrategy());119        rideMatchingService2.matchRider("Downtown");120    }121}122

Strategy Pattern: Dynamic Runtime Interchangeability