DEV Community: NOOB

LLD-8:Pizza Topping System

NOOB — Mon, 16 Feb 2026 05:18:05 +0000

Pizza Topping System - Decorator Pattern Implementation

This is an implementation of the Decorator design pattern for a pizza shop billing system demonstrating how to stack multiple decorators of the same type for customizable orders.

Problem Statement

Building a billing system for a Pizza shop where customers can add multiple toppings, including multiple instances of the same topping. The challenge is handling orders like "Double Cheese Paneer Margherita" where the same decorator (Cheese) is applied twice.

Key Challenge: A customer wants:

Margherita + ExtraCheese + ExtraCheese + Paneer
Total Cost: ₹100 + ₹20 + ₹20 + ₹60 = ₹200
Must support stacking the same decorator multiple times

Class Diagram

          +----------------+
          |     Pizza      | <-------------------------+
          |   (Interface)  |                           |
          +----------------+                           |
          | + getCost()    |                           |
          | + getDesc()    |                           |
          +-------+--------+                           |
                  ^                                    |
                  | (Implements)                       |
                  |                                    | (Wraps / Has-A)
       +----------+-----------+             +----------+----------+
       |                      |             |                     |
 +-----+-----------+    +-----+-------------+---+      +----------+----------+
 | MargheritaPizza |    |     PizzaDecorator    |<>----|     pizza field     |
 +-----------------+    |       (Abstract)      |      +---------------------+
 | Returns 100.0   |    +-----------------------+
 +-----------------+              ^
                                  | (Extends)
                                  |
                   +--------------+--------------+
                   |                             |
          +--------+--------+           +--------+--------+
          | CheeseDecorator |           | PaneerDecorator |
          +-----------------+           +-----------------+
          | + getCost()     |           | + getCost()     |
          |   return 20.0   |           |   return 60.0   |
          |   + super.cost  |           |   + super.cost  |
          +-----------------+           +-----------------+

Implementation

package decorator.pizzatoppingsystem;

/**
 * Pizza Topping System using the Decorator Pattern.
 * Demonstrates recursive composition to calculate total cost.
 */
public class PizzaToppingSystem {

    /**
     * Component Interface.
     * Defines the blueprint for Base Pizzas and Decorators.
     */
    interface Pizza {
        String getDescription();
        double getCost();
    }

    /**
     * Concrete Component (The Base Object).
     */
    static class MargheritaPizza implements Pizza {
        @Override
        public String getDescription() {
            return "Margherita Pizza";
        }

        @Override
        public double getCost() {
            return 100.00;
        }
    }

    /**
     * Abstract Decorator.
     * Contains a reference to a Pizza object (HAS-A relationship).
     */
    static abstract class PizzaDecorator implements Pizza {
        protected Pizza pizza; // The object being wrapped

        public PizzaDecorator(Pizza pizza) {
            this.pizza = pizza;
        }

        @Override
        public String getDescription() {
            return pizza.getDescription(); // Delegate to wrapped object
        }

        @Override
        public double getCost() {
            return pizza.getCost(); // Delegate to wrapped object
        }
    }

    /**
     * Concrete Decorator (Adds Cheese).
     */
    static class CheeseDecorator extends PizzaDecorator {
        public CheeseDecorator(Pizza pizza) {
            super(pizza);
        }

        @Override
        public String getDescription() {
            return super.getDescription() + ", Cheese";
        }

        @Override
        public double getCost() {
            return super.getCost() + 20.00;
        }
    }

    /**
     * Concrete Decorator (Adds Paneer).
     */
    static class PaneerDecorator extends PizzaDecorator {
        public PaneerDecorator(Pizza pizza) {
            super(pizza);
        }

        @Override
        public String getDescription() {
            return super.getDescription() + ", Paneer";
        }

        @Override
        public double getCost() {
            return super.getCost() + 60.00;
        }
    }

    public static void main(String[] args) {
        System.out.println("---- Pizza Shop Order ----");

        // 1. Order Base Pizza
        Pizza margheritaPizza = new MargheritaPizza();
        System.out.println(margheritaPizza.getDescription() + " : Rs. " + 
                         margheritaPizza.getCost());

        // 2. Add Cheese
        margheritaPizza = new CheeseDecorator(margheritaPizza);
        System.out.println(margheritaPizza.getDescription() + " : Rs. " + 
                         margheritaPizza.getCost());

        // 3. Add Extra Cheese (Recursion)
        margheritaPizza = new CheeseDecorator(margheritaPizza);
        System.out.println(margheritaPizza.getDescription() + " : Rs. " + 
                         margheritaPizza.getCost());

        // 4. Add Paneer
        margheritaPizza = new PaneerDecorator(margheritaPizza);
        System.out.println(margheritaPizza.getDescription() + " : Rs. " + 
                         margheritaPizza.getCost());
    }
}

Key Features

Decorator Pattern: Dynamically adds toppings to pizza without modifying base class
Recursive Stacking: Same decorator can be applied multiple times (double cheese, triple cheese, etc.)
Flexible Combinations: Any combination of toppings in any order
Composition over Inheritance: Uses wrapping instead of creating subclasses for each combination
Open/Closed Principle: Open for extension, closed for modification
Cost Accumulation: Each decorator adds its cost to the wrapped object's cost

How It Works

Component Interface (Pizza): Defines common operations for base pizzas and decorators
Concrete Component (MargheritaPizza): The base pizza without any toppings
Abstract Decorator (PizzaDecorator): Holds a reference to a Pizza object and delegates operations
Concrete Decorators (CheeseDecorator, PaneerDecorator): Add specific toppings and costs
Recursive Wrapping: Each decorator wraps the previous object, creating a nested chain

Sample Output

---- Pizza Shop Order ----
Margherita Pizza : Rs. 100.0
Margherita Pizza, Cheese : Rs. 120.0
Margherita Pizza, Cheese, Cheese : Rs. 140.0
Margherita Pizza, Cheese, Cheese, Paneer : Rs. 200.0

Visualization of Recursive Wrapping

Order: Margherita + Cheese + Cheese + Paneer

PaneerDecorator (₹60)
    └── wraps CheeseDecorator (₹20)
            └── wraps CheeseDecorator (₹20)
                    └── wraps MargheritaPizza (₹100)

When getCost() is called:
1. PaneerDecorator.getCost() = super.getCost() + 60.00
2. CheeseDecorator.getCost() = super.getCost() + 20.00
3. CheeseDecorator.getCost() = super.getCost() + 20.00
4. MargheritaPizza.getCost() = 100.00
5. Result: 100.00 + 20.00 + 20.00 + 60.00 = 200.00

Real-World Applications

Pizza ordering systems (Domino's, Pizza Hut)
Burger customization (extra patties, extra cheese)
Sandwich builders (Subway)
Ice cream with multiple scoops and toppings
Car wash packages (basic + wax + tire shine)
Software feature bundles
Cloud service add-ons

Key Advantage: Stacking Same Decorator

Problem Without Decorator:

Need separate classes: PizzaWithCheese, PizzaWithDoubleCheese, PizzaWithTripleCheese
Exponential class explosion with combinations

Solution With Decorator:

Pizza pizza = new MargheritaPizza();
pizza = new CheeseDecorator(pizza);  // Add cheese once
pizza = new CheeseDecorator(pizza);  // Add cheese again
pizza = new CheeseDecorator(pizza);  // Add cheese third time
// Can stack indefinitely!

Adding New Toppings

Adding a new topping is straightforward:

static class OlivesDecorator extends PizzaDecorator {
    public OlivesDecorator(Pizza pizza) {
        super(pizza);
    }

    @Override
    public String getDescription() {
        return super.getDescription() + ", Olives";
    }

    @Override
    public double getCost() {
        return super.getCost() + 15.00;
    }
}

No need to modify existing code - just add the new decorator class!

Extension Ideas

// Create complex orders easily
Pizza vegSupreme = new MargheritaPizza();
vegSupreme = new CheeseDecorator(vegSupreme);
vegSupreme = new PaneerDecorator(vegSupreme);
vegSupreme = new OlivesDecorator(vegSupreme);
vegSupreme = new MushroomDecorator(vegSupreme);
vegSupreme = new CheeseDecorator(vegSupreme);  // Extra cheese on top!

System.out.println(vegSupreme.getDescription() + " : Rs. " + vegSupreme.getCost());
// Output: Margherita Pizza, Cheese, Paneer, Olives, Mushroom, Cheese : Rs. 235.0

LLD-7:Coffee Shop System

NOOB — Mon, 16 Feb 2026 04:29:28 +0000

Coffee Shop System - Decorator Pattern Implementation

This is an implementation of the Decorator design pattern for a coffee shop billing system where customers can dynamically add various toppings to their base coffee order.

Problem Statement

Building billing software for a coffee shop (like Starbucks) where customers can customize their coffee with various add-ons. The challenge is to handle dynamic combinations of add-ons without creating separate classes for every possible combination (Coffee, CoffeeWithMilk, CoffeeWithSugar, CoffeeWithMilkAndSugar, etc.).

Key Challenge: A customer can order:

Just Coffee
Coffee + Milk
Coffee + Milk + Sugar
Coffee + Milk + Milk (Double Milk!)
Any combination of add-ons in any order

Class Diagram

          +----------------+
          |     Coffee     | <-------------------------+
          |   (Interface)  |                           |
          +----------------+                           |
          | + getCost()    |                           |
          | + getDesc()    |                           |
          +-------+--------+                           |
                  ^                                    |
                  | (Implements)                       |
                  |                                    | (Wraps / Has-A)
       +----------+-----------+             +----------+----------+
       |                      |             |                     |
 +-----+--------+    +--------+-------------+---+      +----------+----------+
 | SimpleCoffee |    |      CoffeeDecorator     |<>----|   coffee field      |
 +--------------+    |         (Abstract)       |      +---------------------+
 | Returns 10.0 |    +--------------------------+
 +--------------+                 ^
                                  | (Extends)
                                  |
                   +--------------+--------------+
                   |                             |
          +--------+--------+           +--------+--------+
          |  MilkDecorator  |           |  SugarDecorator |
          +-----------------+           +-----------------+
          | + getCost()     |           | + getCost()     |
          |   return 2.0    |           |   return 5.0    |
          |   + super.cost  |           |   + super.cost  |
          +-----------------+           +-----------------+

Implementation

package decorator.coffeeshopsystem;

public class CoffeeShopSystem {

    /**
     * Component Interface.
     * Defines the blueprint for both the base object and the decorators.
     */
    interface Coffee {
        String getDescription();
        double getCost();
    }

    /**
     * Concrete Component.
     * The base object (plain coffee) that we will decorate.
     */
    static class SimpleCoffee implements Coffee {
        @Override
        public String getDescription() {
            return "Simple Coffee";
        }

        @Override
        public double getCost() {
            return 10.0;
        }
    }

    /**
     * Abstract Decorator.
     * Implements the interface AND holds a reference to a Component (HAS-A relationship).
     */
    static abstract class CoffeeDecorator implements Coffee {
        protected Coffee coffee; // The object being wrapped

        public CoffeeDecorator(Coffee coffee) {
            this.coffee = coffee;
        }

        @Override
        public String getDescription() {
            return coffee.getDescription(); // Delegate to the wrapped object
        }

        @Override
        public double getCost() {
            return coffee.getCost(); // Delegate to the wrapped object
        }
    }

    /**
     * Concrete Decorator (Milk).
     * Adds functionality (cost and description) to the wrapped object.
     */
    static class MilkDecorator extends CoffeeDecorator {
        public MilkDecorator(Coffee coffee) {
            super(coffee);
        }

        @Override
        public String getDescription() {
            return super.getDescription() + ", Milk";
        }

        @Override
        public double getCost() {
            return super.getCost() + 2.0; // Add cost of Milk
        }
    }

    /**
     * Concrete Decorator (Sugar).
     * Adds functionality (cost and description) to the wrapped object.
     */
    static class SugarDecorator extends CoffeeDecorator {
        public SugarDecorator(Coffee coffee) {
            super(coffee);
        }

        @Override
        public String getDescription() {
            return super.getDescription() + ", Sugar";
        }

        @Override
        public double getCost() {
            return super.getCost() + 5.0; // Add cost of Sugar
        }
    }

    public static void main(String[] args) {
        System.out.println("---- Coffee Shop Order ----");

        // 1. Order Base Coffee
        Coffee myCoffee = new SimpleCoffee();
        System.out.println(myCoffee.getDescription() + " : $" + myCoffee.getCost());

        // 2. Decorate with Milk
        myCoffee = new MilkDecorator(myCoffee);
        System.out.println(myCoffee.getDescription() + " : $" + myCoffee.getCost());

        // 3. Decorate with Sugar
        myCoffee = new SugarDecorator(myCoffee);
        System.out.println(myCoffee.getDescription() + " : $" + myCoffee.getCost());
    }
}

Key Features

Decorator Pattern: Dynamically adds responsibilities to objects without modifying their classes
Flexible Combinations: Supports any combination of add-ons in any order
Open/Closed Principle: Open for extension (new decorators), closed for modification
Single Responsibility: Each decorator has one specific responsibility
Composition over Inheritance: Uses wrapping instead of subclassing
Stackable Decorators: Can apply multiple decorators to the same object

How It Works

Component Interface (Coffee): Defines the common interface for both base objects and decorators
Concrete Component (SimpleCoffee): The basic coffee without any add-ons
Abstract Decorator (CoffeeDecorator): Implements the Coffee interface and holds a reference to a Coffee object
Concrete Decorators (MilkDecorator, SugarDecorator): Add specific functionality by wrapping the coffee object
Wrapping Process: Each decorator wraps the previous object, creating a chain of decorators

Sample Output

---- Coffee Shop Order ----
Simple Coffee : $10.0
Simple Coffee, Milk : $12.0
Simple Coffee, Milk, Sugar : $17.0

Visualization of Wrapping

Order: Coffee + Milk + Sugar

SugarDecorator
    └── wraps MilkDecorator
            └── wraps SimpleCoffee

When getCost() is called:
1. SugarDecorator.getCost() = super.getCost() + 5.0
2. MilkDecorator.getCost() = super.getCost() + 2.0
3. SimpleCoffee.getCost() = 10.0
4. Result: 10.0 + 2.0 + 5.0 = 17.0

Real-World Applications

Coffee shop ordering systems (Starbucks, Dunkin')
Pizza topping customization
Car configuration with optional features
Insurance policy add-ons
Software licensing with feature modules
Stream/IO operations in Java (BufferedReader wrapping FileReader)
UI component decoration (borders, scrollbars)

Advantages Over Inheritance

Without Decorator (Using Inheritance):

CoffeeWithMilk
CoffeeWithSugar
CoffeeWithMilkAndSugar
CoffeeWithDoubleMilk
CoffeeWithDoubleMilkAndSugar
... (Class explosion!)

With Decorator:

SimpleCoffee
MilkDecorator
SugarDecorator
Can create any combination dynamically!

Adding New Decorators

Adding a new add-on is simple:

static class WhippedCreamDecorator extends CoffeeDecorator {
    public WhippedCreamDecorator(Coffee coffee) {
        super(coffee);
    }

    @Override
    public String getDescription() {
        return super.getDescription() + ", Whipped Cream";
    }

    @Override
    public double getCost() {
        return super.getCost() + 3.0;
    }
}

No need to modify existing code - just add the new decorator class!

LLD-6:YouTube Subscription System

NOOB — Sat, 14 Feb 2026 23:28:02 +0000

YouTube Subscription System - Observer Pattern Implementation

This is an implementation of the Observer design pattern for a YouTube-style subscription system demonstrating many-to-many relationships where multiple users can subscribe to multiple channels.

Problem Statement

Designing the notification backend for YouTube where multiple channels (Subjects) can have multiple subscribers (Observers), and each channel maintains its own independent subscriber list. When a channel uploads a video, only its subscribers should be notified - not subscribers of other channels.

Key Challenge: Managing independent notification lists for multiple subjects where:

Shiv subscribes to MrBeast
Tina subscribes to MrBeast AND GFG
Laxmi subscribes to T-Series
When MrBeast uploads, only Shiv and Tina get notified (not Laxmi)

Class Diagram

        +------------------+             +-----------------------+
        |     Subject      |             |       Observer        |
        |   (Interface)    |             |      (Interface)      |
        +------------------+             +-----------------------+
        | + subscribe()    |             | + update()            |
        | + unsubscribe()  |             +-----------+-----------+
        | + notify()       |                         ^
        +--------+---------+                         |
                 ^                                   | (Implements)
                 | (Implements)                      |
                 |                                   |
        +--------+---------+             +-----------+-----------+
        |  YoutubeChannel  |<>---------->|      YouTubeUser      |
        +------------------+   (List)    +-----------------------+
        | - channelName    |             | - userName            |
        | - subscribers [] |             | + update(msg)         |
        | + uploadVideo()  |             +-----------------------+
        +------------------+

Implementation

package observer.youtubesubscriptionsystem;

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

/**
 * YouTube Subscription System demonstrating Many-to-Many Observer Pattern.
 */
public class YoutubeSubscriptionSystem {

    /**
     * Observer interface for Users.
     */
    interface Observer {
        void update(String channelName, String videoTitle);
    }

    /**
     * Subject interface for Channels.
     */
    interface Subject {
        void subscribe(Observer observer);
        void unsubscribe(Observer observer);
        void notifySubscribers(String videoTitle);
    }

    /**
     * Concrete Subject representing a specific YouTube Channel.
     */
    static class YoutubeChannel implements Subject {
        private final String channelName;
        private final List<Observer> subscribers = new ArrayList<>();

        public YoutubeChannel(String channelName) {
            this.channelName = channelName;
        }

        @Override
        public void subscribe(Observer observer) {
            subscribers.add(observer);
            System.out.println("[System] New Subscriber added to " + this.channelName);
        }

        @Override
        public void unsubscribe(Observer observer) {
            subscribers.remove(observer);
            System.out.println("[System] Subscriber removed from " + this.channelName);
        }

        @Override
        public void notifySubscribers(String videoTitle) {
            for (Observer observer : subscribers) {
                observer.update(this.channelName, videoTitle);
            }
        }

        /**
         * Simulates a video upload and notifies subscribers.
         */
        public void uploadVideo(String videoTitle) {
            System.out.println("\n------------------------------------");
            System.out.println("Uploading to [" + this.channelName + "]: " + 
                             videoTitle);
            System.out.println("------------------------------------");
            notifySubscribers(videoTitle);
        }
    }

    /**
     * Concrete Observer representing a User.
     */
    static class YouTubeUser implements Observer {
        private final String userName;

        public YouTubeUser(String userName) {
            this.userName = userName;
        }

        @Override
        public void update(String channelName, String videoTitle) {
            System.out.println(" => [Notification] Hey " + userName + ", " + 
                             channelName + " just uploaded: \"" + videoTitle + "\"");
        }
    }

    public static void main(String[] args) {
        YoutubeChannel mrBeast = new YoutubeChannel("MrBeast");
        YoutubeChannel gfg = new YoutubeChannel("GFG");
        YoutubeChannel tseries = new YoutubeChannel("T-Series");

        Observer shiv = new YouTubeUser("Shiv");
        Observer tina = new YouTubeUser("Tina");
        Observer laxmi = new YouTubeUser("Laxmi");

        System.out.println("----Setting up Subscriptions----");

        // Shiv follows MrBeast
        mrBeast.subscribe(shiv);

        // Tina follows MrBeast AND GFG
        mrBeast.subscribe(tina);
        gfg.subscribe(tina);

        // Laxmi follows T-Series
        tseries.subscribe(laxmi);

        // --- SCENARIO 1: Uploads ---
        mrBeast.uploadVideo("I Built a Chocolate Factory!");
        gfg.uploadVideo("Observer pattern in 5 mins");
        tseries.uploadVideo("New Punjabi Song");

        // --- SCENARIO 2: Unsubscribe ---
        System.out.println("\n----Laxmi Unsubscribes from T-Series----");
        tseries.unsubscribe(laxmi);

        tseries.uploadVideo("Another Hit Song");
    }
}

Key Features

Many-to-Many Relationship: Users can subscribe to multiple channels, channels can have multiple subscribers
Independent Subscriber Lists: Each channel maintains its own list of subscribers
Targeted Notifications: Only relevant subscribers receive notifications
Dynamic Subscriptions: Users can subscribe and unsubscribe at runtime
Personalized Notifications: Each notification includes both channel name and video title
Extensible: Easy to add new channels and users without modifying existing code

How It Works

Multiple Subjects: Each YouTube channel is an independent subject with its own subscriber list
Multiple Observers: Users can subscribe to any number of channels
Subscription: Users call channel.subscribe(user) to start receiving notifications
Upload & Notify: When a channel uploads via uploadVideo(), only its subscribers are notified
Unsubscription: Users can call channel.unsubscribe(user) to stop receiving notifications

Sample Output

----Setting up Subscriptions----
[System] New Subscriber added to MrBeast
[System] New Subscriber added to MrBeast
[System] New Subscriber added to GFG
[System] New Subscriber added to T-Series

------------------------------------
Uploading to [MrBeast]: I Built a Chocolate Factory!
------------------------------------
 => [Notification] Hey Shiv, MrBeast just uploaded: "I Built a Chocolate Factory!"
 => [Notification] Hey Tina, MrBeast just uploaded: "I Built a Chocolate Factory!"

------------------------------------
Uploading to [GFG]: Observer pattern in 5 mins
------------------------------------
 => [Notification] Hey Tina, GFG just uploaded: "Observer pattern in 5 mins"

------------------------------------
Uploading to [T-Series]: New Punjabi Song
------------------------------------
 => [Notification] Hey Laxmi, T-Series just uploaded: "New Punjabi Song"

----Laxmi Unsubscribes from T-Series----
[System] Subscriber removed from T-Series

------------------------------------
Uploading to [T-Series]: Another Hit Song
------------------------------------

Notice how after Laxmi unsubscribes, the last T-Series upload doesn't generate any notification!

Real-World Applications

YouTube subscription and notification system
Social media follow/follower systems (Twitter, Instagram)
Newsletter subscription platforms
Podcast notification systems
Blog RSS feed subscriptions
Event notification systems
Push notification services

Key Differences from Previous Examples

Unlike the Weather Station or Stock Market examples where there was typically one subject broadcasting to multiple observers, this system demonstrates:

Multiple independent subjects (channels)
Many-to-many relationships (users subscribe to multiple channels)
Isolated notification lists (each channel has its own subscribers)
Cross-subscription (same user can observe multiple subjects)

LLD-5.5:Traffic Signal System

NOOB — Sat, 14 Feb 2026 21:23:38 +0000

Traffic Signal System - Observer Pattern Implementation

This is an implementation of the Observer design pattern for a Smart City traffic intersection where vehicles and pedestrians react differently to the same signal changes.

Problem Statement

Designing software for a Smart City intersection where a traffic signal changes colors (RED, GREEN) and different types of observers must react appropriately. The unique challenge here is that unlike typical observer patterns where all observers handle updates similarly, vehicles and pedestrians have opposite behaviors for the same signal state.

Key Challenge:

When signal is GREEN → Cars GO, Pedestrians WAIT
When signal is RED → Cars STOP, Pedestrians WALK

Class Diagram

        +------------------+             +-----------------------+
        |     Subject      |             |       Observer        |
        |   (Interface)    |             |      (Interface)      |
        +------------------+             +-----------------------+
        | + add(obs)       |             | + update(color)       |
        | + remove(obs)    |             +-----------+-----------+
        | + notify()       |                         ^
        +--------+---------+                         |
                 ^                                   | (Implements)
                 | (Implements)                      |
                 |                                   |
        +--------+---------+             +-----------+-----------+----------------+
        |  SignalStation   |<>---------->|                       |                |
        +------------------+   (List)    |  +----------------+   |  +----------+  |
        | - observers List |             |  | VehicleObserver|   |  |WalkObserver| |
        | - signalColor    |             |  +----------------+   |  +----------+  |
        | + updateSignal() |             |  | - name         |   |  | -name      | |
        +------------------+             |  | + update()     |   |  | +update()  | |
                                         |  +----------------+   |  +----------+  |
                                         +-----------------------+----------------+

Implementation

package observer.trafficsignalsystem;

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

/**
 * Main system demonstrating the Observer Pattern for traffic control.
 * Vehicles and Pedestrians react differently to the same signal change.
 */
public class TrafficSignalSystem {

    /**
     * Enum defining the possible states of a traffic signal.
     */
    enum SignalColor {
        GREEN,
        RED
    }

    /**
     * Observer interface for any entity reacting to traffic lights.
     */
    interface Observer {
        /**
         * Triggered when the signal color changes.
         */
        void update(SignalColor signalColor);
    }

    /**
     * Subject interface for managing subscriptions.
     */
    interface Subject {
        void addObserver(Observer observer);
        void removeObserver(Observer observer);
        void notifyObservers();
    }

    /**
     * Concrete Subject acting as the Traffic Signal Station.
     */
    static class SignalStation implements Subject {
        private final List<Observer> observers = new ArrayList<>();
        private SignalColor signalColor;

        @Override
        public void addObserver(Observer observer) {
            observers.add(observer);
        }

        @Override
        public void removeObserver(Observer observer) {
            observers.remove(observer);
        }

        @Override
        public void notifyObservers() {
            for (Observer observer : observers) {
                observer.update(signalColor);
            }
        }

        /**
         * Updates the signal color and triggers notification.
         */
        public void updateTrafficSignal(SignalColor signalColor) {
            this.signalColor = signalColor;
            System.out.println("\n[SignalStation] Signal changed to: " + signalColor);
            notifyObservers();
        }
    }

    /**
     * Concrete Observer representing a Vehicle.
     * Stops on RED, Moves on GREEN.
     */
    static class VehicleObserver implements Observer {
        private final String name;

        public VehicleObserver(String name) {
            this.name = name;
        }

        @Override
        public void update(SignalColor signalColor) {
            if (signalColor == SignalColor.GREEN) {
                System.out.println("  [Car] " + name + ": Green Light! Vroom Vroom...");
            } else {
                System.out.println("  [Car] " + name + ": Red Light! Screech... Stop.");
            }
        }
    }

    /**
     * Concrete Observer representing a Pedestrian.
     * Stops on GREEN, Moves on RED.
     */
    static class WalkObserver implements Observer {
        private final String name;

        public WalkObserver(String name) {
            this.name = name;
        }

        @Override
        public void update(SignalColor signalColor) {
            if (signalColor == SignalColor.GREEN) {
                System.out.println("  [Walker] " + name + 
                                 ": Green Light! Wait for cars.");
            } else {
                System.out.println("  [Walker] " + name + 
                                 ": Red Light! Safe to cross.");
            }
        }
    }

    /**
     * Main driver method to simulate the traffic signal logic.
     */
    public static void main(String[] args) {
        SignalStation suratTrafficStation = new SignalStation();

        System.out.println("\n----Simulation Started----\n");

        Observer walker1 = new WalkObserver("Shiv");
        Observer car1 = new VehicleObserver("BMW");

        suratTrafficStation.addObserver(walker1);
        suratTrafficStation.addObserver(car1);

        System.out.println("\n------- Signal -> GREEN -------");
        suratTrafficStation.updateTrafficSignal(SignalColor.GREEN);

        System.out.println("\n------- Signal -> RED -------");
        suratTrafficStation.updateTrafficSignal(SignalColor.RED);
    }
}

Key Features

Observer Pattern: Implements one-to-many dependency for traffic signal updates
Opposite Behaviors: Different observers react differently to the same event
Type Safety: Uses Enum for signal colors instead of strings
Extensible: Easy to add new observer types (Bicycles, Emergency Vehicles, etc.)
Real-time Coordination: All observers receive updates simultaneously
Loose Coupling: SignalStation doesn't need to know about specific observer implementations

How It Works

Subject (SignalStation): Maintains the current signal color and list of observers
Observers (VehicleObserver, WalkObserver): Implement different logic for the same signal state
Registration: Vehicles and pedestrians register using addObserver()
State Change: When signal changes via updateTrafficSignal(), all observers are notified
Custom Logic: Each observer type implements its own behavior based on the signal color

Sample Output

----Simulation Started----


------- Signal -> GREEN -------

[SignalStation] Signal changed to: GREEN
  [Walker] Shiv: Green Light! Wait for cars.
  [Car] BMW: Green Light! Vroom Vroom...

------- Signal -> RED -------

[SignalStation] Signal changed to: RED
  [Walker] Shiv: Red Light! Safe to cross.
  [Car] BMW: Red Light! Screech... Stop.

Real-World Applications

Smart City traffic management systems
Autonomous vehicle coordination
Pedestrian crossing safety systems
Emergency vehicle priority signaling
Traffic flow optimization
Intersection collision avoidance

Extensions

This pattern can be extended to support:

ORANGE/YELLOW signals for warning states
Emergency vehicles that override normal behavior
Bicycles with different rules than cars
Traffic statistics observers that log traffic patterns
Adaptive signals that adjust timing based on traffic density

LLD-5:Stock Market Notification System

NOOB — Sat, 14 Feb 2026 17:35:35 +0000

Stock Market Notification System - Observer Pattern Implementation

This is an implementation of the Observer design pattern for a trading application where investors receive real-time stock price updates through different notification channels.

Problem Statement

Building a backend for a trading app like Zerodha or Robinhood where multiple investors need to be notified when stock prices change. Unlike simple notifications, stock updates need to convey both the stock name and the current price. Different investors may prefer different notification channels (email, mobile app, SMS, etc.).

Key Challenge: The system must support personalized notifications for multiple users across different communication channels, while maintaining loose coupling between the stock ticker and the notification mechanisms.

Class Diagram

        +------------------+             +-----------------------+
        |     Subject      |             |       Observer        |
        |   (Interface)    |             |      (Interface)      |
        +------------------+             +-----------------------+
        | + add(obs)       |             | + update(name, price) |
        | + remove(obs)    |             +-----------+-----------+
        | + notify()       |                         ^
        +--------+---------+                         |
                 ^                                   | (Implements)
                 | (Implements)                      |
                 |                                   |
        +--------+---------+             +-----------+-----------+----------------+
        |   StockTicker    |<>---------->|                       |                |
        +------------------+   (List)    |  +----------------+   |  +----------+  |
        | - observers List |             |  | EmailObserver  |   |  |AppObserver| |
        | - stockName      |             |  +----------------+   |  +----------+  |
        | - stockPrice     |             |  | - username     |   |  | -username|  |
        | + setStockPrice()|             |  | + update()     |   |  | +update()|  |
        +------------------+             |  +----------------+   |  +----------+  |
                                         +-----------------------+----------------+

Implementation

package observer.stockmarketnotificationsystem;

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

/**
 * Main class for the Stock Market Notification System.
 * Demonstrates the Observer Pattern with distinct User Identities.
 */
public class StockMarketNotificationSystem {

    /**
     * Observer Interface.
     * Represents the "Investor" who wants to be notified.
     */
    interface Observer {
        void update(String stockName, double stockPrice);
    }

    /**
     * Subject Interface.
     * Represents the "Stock Market" or "Ticker" that broadcasts updates.
     */
    interface Subject {
        void addObserver(Observer observer);
        void removeObserver(Observer observer);
        void notifyObservers();
    }

    /**
     * Concrete Subject.
     * This acts as the central ticker. When a stock updates, it alerts everyone.
     */
    static class StockTicker implements Subject {
        // List to hold all subscribed investors
        private final List<Observer> observers = new ArrayList<>();

        private String stockName;
        private double stockPrice;

        @Override
        public void addObserver(Observer observer) {
            observers.add(observer);
        }

        @Override
        public void removeObserver(Observer observer) {
            observers.remove(observer);
        }

        @Override
        public void notifyObservers() {
            for (Observer observer : observers) {
                // Pass the state to the observers
                observer.update(stockName, stockPrice);
            }
        }

        public void setStockPrice(String stockName, double stockPrice) {
            this.stockName = stockName;
            this.stockPrice = stockPrice;
            System.out.println("\n[Ticker] New Update: " + stockName + 
                             " is now $" + stockPrice);
            notifyObservers();
        }
    }

    /**
     * Concrete Observer for Email Alerts.
     * Contains the User's Name to make it personalized.
     */
    static class EmailObserver implements Observer {
        private final String username;

        public EmailObserver(String username) {
            this.username = username;
        }

        @Override
        public void update(String stockName, double stockPrice) {
            System.out.println("  -> Email sent to " + username + ": " + 
                             stockName + " is at $" + stockPrice);
        }
    }

    /**
     * Concrete Observer for Mobile App Alerts.
     */
    static class AppObserver implements Observer {
        private final String username;

        public AppObserver(String username) {
            this.username = username;
        }

        @Override
        public void update(String stockName, double stockPrice) {
            System.out.println("  -> App Notification for " + username + ": " + 
                             stockName + " is at $" + stockPrice);
        }
    }

    /**
     * Main Driver Method.
     */
    public static void main(String[] args) {
        StockTicker zerodha = new StockTicker();

        System.out.println("\n--- Simulation Started ---");

        // 1. Create Observers with Names (Identity)
        Observer shiv = new AppObserver("Shiv");
        Observer tina = new AppObserver("Tina");
        Observer laxmi = new EmailObserver("Laxmi");

        // 2. Subscribe them
        zerodha.addObserver(shiv);
        zerodha.addObserver(tina);
        zerodha.addObserver(laxmi);

        // 3. Update Price - Everyone gets notified
        zerodha.setStockPrice("Apple", 238.92);

        // 4. Unsubscribe Logic
        System.out.println("\n--- Shiv unsubscribes ---");
        zerodha.removeObserver(shiv);

        // 5. Update Price again - Shiv should NOT receive this
        zerodha.setStockPrice("Tesla", 500.00);
    }
}

Key Features

Observer Pattern: Implements one-to-many dependency for stock price updates
Personalized Notifications: Each observer has a username for personalized messages
Multiple Notification Channels: Supports email, mobile app, and easily extensible to SMS, desktop, etc.
Multi-parameter Updates: Unlike simple observer patterns, this passes both stock name and price
Dynamic Subscription: Investors can subscribe and unsubscribe at runtime
Loose Coupling: StockTicker doesn't need to know about specific notification implementations

How It Works

Subject (StockTicker): Maintains stock state and list of observers
Observers (EmailObserver, AppObserver): Implement the Observer interface with personalized identities
Registration: Investors register using addObserver()
Notification: When stock price changes via setStockPrice(), all registered observers receive updates with both stock name and price
Unsubscription: Investors can unsubscribe using removeObserver()

Sample Output

--- Simulation Started ---

[Ticker] New Update: Apple is now $238.92
  -> App Notification for Shiv: Apple is at $238.92
  -> App Notification for Tina: Apple is at $238.92
  -> Email sent to Laxmi: Apple is at $238.92

--- Shiv unsubscribes ---

[Ticker] New Update: Tesla is now $500.0
  -> App Notification for Tina: Tesla is at $500.0
  -> Email sent to Laxmi: Tesla is at $500.0

Real-World Applications

Stock trading platforms (Zerodha, Robinhood, E*TRADE)
Cryptocurrency price tracking
Real-time sports score updates
News notification systems
Social media feed updates

LLD-4:Weather Monitoring System

NOOB — Sat, 14 Feb 2026 13:36:10 +0000

Weather Monitoring System - Observer Pattern Implementation

This is an implementation of the Observer design pattern for a weather monitoring application where multiple displays automatically update when the weather station detects temperature changes.

Problem Statement

Building a weather application where a central WeatherStation tracks temperature and multiple display devices (Phone, TV, Smartwatch, etc.) need to show the current temperature. When the temperature updates, all connected displays must update automatically without the WeatherStation knowing the specific details of each display.

Key Challenge: The system must be extensible - adding new display types shouldn't require modifying the WeatherStation code.

Class Diagram

        +------------------+             +-----------------------+
        |     Subject      |             |       Observer        |
        |   (Interface)    |             |      (Interface)      |
        +------------------+             +-----------------------+
        | + add(obs)       |             | + update(temp)        |
        | + remove(obs)    |             +-----------+-----------+
        | + notify()       |                         ^
        +--------+---------+                         |
                 ^                                   | (Implements)
                 | (Implements)                      |
                 |                                   |
        +--------+---------+             +-----------+-----------+----------------+
        |  WeatherStation  |<>---------->|                       |                |
        +------------------+   (List)    |  +----------------+   |  +----------+  |
        | - observers List |             |  |  PhoneDisplay  |   |  | TVDisplay|  |
        | - temperature    |             |  +----------------+   |  +----------+  |
        | + setTemp(t)     |             |  | - userName     |   |  |          |  |
        +------------------+             |  | + update(t)    |   |  | +update()|  |
                                         |  +----------------+   |  +----------+  |
                                         +-----------------------+----------------+

Implementation

package observer.weathermonitoringsystem;

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

/**
 * Main class for the Weather Monitoring System.
 * Implements the Observer Pattern to decouple the Weather Station from the Displays.
 */
public class WeatherMonitoringSystem {

    /**
     * Observer Interface.
     * Defines the contract that all display devices must follow to receive updates.
     */
    interface Observer {
        void update(String temperature);
    }

    /**
     * Subject Interface.
     * Defines the methods to manage subscribers (observers) and notify them.
     */
    interface Subject {
        void addObserver(Observer observer);
        void removeObserver(Observer observer);
        void notifyObserver();
    }

    /**
     * Concrete Subject (Weather Station).
     * Maintains the state (temperature) and the list of subscribers.
     */
    static class WeatherStation implements Subject {
        private final List<Observer> observers = new ArrayList<>();
        private String temperature;

        @Override
        public void addObserver(Observer observer) {
            observers.add(observer);
        }

        @Override
        public void removeObserver(Observer observer) {
            observers.remove(observer);
        }

        @Override
        public void notifyObserver() {
            for (Observer observer: observers) {
                observer.update(this.temperature);
            }
        }

        public void setTemperature(String newTemperature) {
            System.out.println("\n[Station] New Temperature measured: " + 
                             newTemperature);
            this.temperature = newTemperature;
            notifyObserver();
        }
    }

    /**
     * Concrete Observer (Phone Display).
     * Displays the temperature on a user's mobile device.
     */
    static class PhoneDisplay implements Observer {
        private final String userName;

        public PhoneDisplay(String userName) {
            this.userName = userName;
        }

        @Override
        public void update(String temperature) {
            System.out.println(" => Phone Display (" + userName + 
                             ") Temperature is now " + temperature);
        }
    }

    /**
     * Concrete Observer (TV Display).
     * Displays the temperature on a large screen.
     */
    static class TVDisplay implements Observer {
        @Override
        public void update(String temperature) {
            System.out.println(" => Tv Display (Living Room): Breaking News! " +
                             "Temperature is " + temperature);
        }
    }

    /**
     * Main driver method to simulate the application flow.
     */
    public static void main(String[] args) {
        WeatherStation station = new WeatherStation();

        Observer shivPhone = new PhoneDisplay("Shiv");
        Observer livingRoomTV = new TVDisplay();

        System.out.println("----Registering Observer----");
        station.addObserver(shivPhone);
        station.addObserver(livingRoomTV);

        // First update: Both displays should receive it
        station.setTemperature("30C");

        System.out.println("\n----Shiv Unsubscribes----");
        station.removeObserver(shivPhone);

        // Second update: Only TV should receive it
        station.setTemperature("28C");
    }
}

Key Features

Observer Pattern: Implements one-to-many dependency between objects
Loose Coupling: WeatherStation doesn't need to know about specific display implementations
Dynamic Subscription: Observers can subscribe and unsubscribe at runtime
Automatic Updates: All registered observers are notified automatically when state changes
Extensible: New display types can be added without modifying existing code

How It Works

Subject (WeatherStation): Maintains a list of observers and notifies them when temperature changes
Observers (Displays): Implement the Observer interface and receive updates via the update() method
Registration: Displays register with the weather station using addObserver()
Notification: When temperature changes, the station calls notifyObserver() which updates all registered displays
Unsubscription: Displays can unsubscribe using removeObserver()

Sample Output

----Registering Observer----

[Station] New Temperature measured: 30C
 => Phone Display (Shiv) Temperature is now 30C
 => Tv Display (Living Room): Breaking News! Temperature is 30C

----Shiv Unsubscribes----

[Station] New Temperature measured: 28C
 => Tv Display (Living Room): Breaking News! Temperature is 28C

LLD-3:Shopping Cart Discount System

NOOB — Sat, 14 Feb 2026 11:09:20 +0000

Shopping Cart Discount System - Strategy Pattern Implementation

This is an implementation of the Strategy design pattern for handling dynamic pricing and discount coupon codes in an e-commerce checkout system.

Problem Statement

Building a pricing engine for an e-commerce site where users can apply different types of coupon codes at checkout. Each discount type requires different calculation logic, but the system must remain flexible and extensible.

Class Diagram

        +------------------+           +-----------------------------+
        |   DiscountType   | <.........|      StrategyFactory        |
        |      (Enum)      |           +-----------------------------+
        +------------------+           | + getStrategy(type, value)  |
                                       +--------------+--------------+
                                                      |
                                                      | (Creates)
                                                      v
        +------------------+           +-----------------------------+
        | DiscountService  |           |      DiscountStrategy       |
        |    (Context)     |           |        (Interface)          |
        +------------------+           +-----------------------------+
        | - strategy       |<>-------->| + applyDiscount(amount)     |
        | + applyCoupon()  |           +--------------+--------------+
        +------------------+                          ^
                                                      | (Implements)
                                                      |
                   +-----------------------+----------+-----------+--------------------------+
                   |                       |                      |                          |
         +--------------------+  +----------------------+  +----------------------------+
         | NoDiscountStrategy |  | FlatDiscountStrategy |  | PercentageDiscountStrategy |
         +--------------------+  +----------------------+  +----------------------------+
         | + apply()          |  | - discountAmount     |  | - percentage               |
         +--------------------+  | + apply()            |  | + apply()                  |
                                 +----------------------+  +----------------------------+

Implementation

package shoppingcartdiscountsystem;

/**
 * Main class for the Shopping Cart Discount System.
 * Implements Strategy Pattern to handle dynamic pricing rules.
 */
public class ShoppingCartDiscountSystem {

    /**
     * Enum to define the supported types of discounts.
     * Ensures type safety and prevents invalid string inputs.
     */
    enum DiscountType {
        NO_DISCOUNT,
        FLAT_DISCOUNT,
        PERCENTAGE_DISCOUNT
    }

    /**
     * Strategy Interface.
     * Defines the contract that all discount algorithms must follow.
     */
    interface DiscountStrategy {
        /**
         * Calculates the final price after applying the discount.
         * @param amount The original total amount.
         * @return The final discounted price.
         */
        Double applyDiscount(Double amount);
    }

    /**
     * Concrete Strategy for No Discount.
     * Returns the original amount as is.
     */
    static class NoDiscountStrategy implements DiscountStrategy {
        @Override
        public Double applyDiscount(Double amount) {
            System.out.println("No Discount Applied with this coupon!");
            return amount;
        }
    }

    /**
     * Concrete Strategy for Flat Amount Discount.
     * Accepts a specific amount (e.g., 50, 100) via constructor.
     */
    static class FlatDiscountStrategy implements DiscountStrategy {
        private final double discountAmount;

        /**
         * Constructor to inject the flat discount value.
         * @param discountAmount The amount to be subtracted (e.g., 50.0).
         */
        public FlatDiscountStrategy(double discountAmount) {
            this.discountAmount = discountAmount;
        }

        @Override
        public Double applyDiscount(Double amount) {
            System.out.println("Flat " + this.discountAmount + 
                             " rs discount applied with this coupon!");
            return Math.max(0, amount - this.discountAmount);
        }
    }

    /**
     * Concrete Strategy for Percentage Discount.
     * Accepts a specific percentage (e.g., 10, 20) via constructor.
     */
    static class PercentageDiscountStrategy implements DiscountStrategy {
        private final double percentage;

        /**
         * Constructor to inject the percentage value.
         * @param percentage The percentage to deduct (e.g., 20.0).
         */
        public PercentageDiscountStrategy(double percentage) {
            this.percentage = percentage;
        }

        @Override
        public Double applyDiscount(Double amount) {
            System.out.println(this.percentage + "% Discount applied with this coupon!");
            return Math.max(0, amount - (amount * (this.percentage / 100)));
        }
    }

    /**
     * Factory Class.
     * Handles the creation of strategies based on the Enum type and value.
     */
    static class StrategyFactory {

        /**
         * Creates the appropriate strategy object.
         * @param discountType The type of discount (Enum).
         * @param value The value for the discount (Amount or Percentage).
         * @return A ready-to-use DiscountStrategy object.
         */
        public static DiscountStrategy getStrategy(DiscountType discountType, double value) {
            switch (discountType) {
                case NO_DISCOUNT -> {
                    return new NoDiscountStrategy();
                }
                case FLAT_DISCOUNT -> {
                    return new FlatDiscountStrategy(value);
                }
                case PERCENTAGE_DISCOUNT -> {
                    return new PercentageDiscountStrategy(value);
                }
                default -> {
                    throw new IllegalArgumentException("Unsupported Discount Type: " + 
                                                      discountType);
                }
            }
        }
    }

    /**
     * Context Class (Discount Service).
     * Manages the active strategy and delegates the calculation.
     */
    static class DiscountService {
        private DiscountStrategy strategy;

        /**
         * Sets the discount strategy dynamically at runtime.
         */
        public void setStrategy(DiscountStrategy strategy) {
            this.strategy = strategy;
        }

        /**
         * Executes the discount logic on the given amount.
         */
        public void applyDiscountCoupon(Double amount) {
            if (strategy == null) {
                System.out.println("Error: No Discount Coupon selected");
                return;
            }

            System.out.println("\n----Getting Discount Coupon-----");
            Double finalAmount = strategy.applyDiscount(amount);
            System.out.println("Final Amount After Discount: " + finalAmount);
            System.out.println("----------------------------------");
        }
    }

    /**
     * Main driver method to simulate the user interaction.
     */
    public static void main(String[] args) {
        DiscountService amazon = new DiscountService();

        System.out.println("Simulation User: Shiv");

        // Scenario 1: No Discount
        try {
            DiscountStrategy strategy = StrategyFactory.getStrategy(
                DiscountType.NO_DISCOUNT, 0.0
            );
            amazon.setStrategy(strategy);
            amazon.applyDiscountCoupon(100.00);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }

        // Scenario 2: Flat Discount (₹50 off)
        try {
            DiscountStrategy strategy = StrategyFactory.getStrategy(
                DiscountType.FLAT_DISCOUNT, 50
            );
            amazon.setStrategy(strategy);
            amazon.applyDiscountCoupon(100.00);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }

        // Scenario 3: Percentage Discount (20% off)
        try {
            DiscountStrategy strategy = StrategyFactory.getStrategy(
                DiscountType.PERCENTAGE_DISCOUNT, 20
            );
            amazon.setStrategy(strategy);
            amazon.applyDiscountCoupon(100.00);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

Key Features

Strategy Pattern: Encapsulates different discount calculation algorithms
Factory Pattern: Centralizes strategy object creation
Dynamic Values: Supports configurable discount amounts and percentages
Type Safety: Uses Enum to prevent invalid discount types
Extensible: Easy to add new discount types (e.g., Buy-One-Get-One, Loyalty Points)
Safety Check: Uses Math.max(0, ...) to prevent negative prices

LLD-2:ECommerces Checkout

NOOB — Fri, 13 Feb 2026 19:32:02 +0000

E-Commerce Payment System - Strategy Pattern Implementation

This is an implementation of the Strategy design pattern for handling multiple payment methods in an e-commerce checkout system.

Problem Statement

Building a backend for an online store like Flipkart or Amazon where users can pay using different payment methods. Each payment method requires different details and processing logic, but the system must remain extensible without using if-else chains.

Class Diagram

        +------------------+           +----------------------+
        |  PaymentRequest  |---------->|    PaymentFactory    |
        +------------------+           +----------------------+
        | - type: Enum     |           | + getStrategy(req)   |
        | - amount: double |           +----------+-----------+
        | - card/upi data  |                      |
        +------------------+                      | (Creates)
                                                  v
        +------------------+           +----------------------+
        |  PaymentService  |           |      PayStrategy     |
        |     (Context)    |           |      (Interface)     |
        +------------------+           +----------------------+
        | - strategy       |<>-------->| + pay(amount)        |
        | + makePayment()  |           +----------+-----------+
        +------------------+                      ^
                                                  | (Implements)
                                                  |
                   +---------------------+--------+--------+----------------------+
                   |                     |                 |                      |
         +--------------------+ +-----------------+ +--------------------+
         | CreditCardStrategy | |   UPIStrategy   | |   PayPalStrategy   |
         +--------------------+ +-----------------+ +--------------------+
         | - cardNumber       | | - upiId         | | - email, password  |
         +--------------------+ +-----------------+ +--------------------+

Implementation

package ecommercecheckout;

/**
 * Main Driver Class for the E-Commerce Payment System.
 * Implements Strategy Pattern (for algorithms) and Factory Pattern (for object creation).
 */
public class ECommerceCheckout {

    /**
     * Enum to define supported payment types.
     * Ensures Type Safety and prevents invalid string inputs.
     */
    enum PaymentType {
        CREDIT_CARD,
        UPI,
        PAYPAL
    }

    /**
     * Data Transfer Object (DTO) for Payment Requests.
     * Acts as a unified form to collect all possible inputs from the user.
     */
    static class PaymentRequest {
        public PaymentType paymentType;
        public double amount;

        // Specific fields for different strategies
        public String cardNumber;
        public String cvv;
        public String expiry;
        public String upiId;
        public String email;
        public String password;
    }

    /**
     * Strategy Interface.
     * Defines the common contract that all payment methods must follow.
     */
    public interface PayStrategy {
        void pay(Double amount);
    }

    /**
     * Concrete Strategy for Credit Card.
     * Uses Constructor Injection to receive card details.
     */
    static class CreditCardStrategy implements PayStrategy {
        private final String cardNumber;
        private final String cvv;
        private final String expiryDate;

        public CreditCardStrategy(String cardNumber, String cvv, String expiryDate) {
            this.cardNumber = cardNumber;
            this.cvv = cvv;
            this.expiryDate = expiryDate;
        }

        @Override
        public void pay(Double amount) {
            System.out.println("Validation Card: " + this.cardNumber);
            System.out.println("Paid " + amount + " successfully");
            System.out.println("Card Details: Card Number => " + this.cardNumber + 
                             " CVV => " + this.cvv + " ExpiryDate => " + expiryDate);
        }
    }

    /**
     * Concrete Strategy for UPI.
     * Encapsulates logic specific to UPI payments.
     */
    static class UPIStrategy implements PayStrategy {
        private final String upiId;

        public UPIStrategy(String upiId) {
            this.upiId = upiId;
        }

        @Override
        public void pay(Double amount) {
            System.out.println("Validating UPI Id: " + this.upiId);
            System.out.println("Paid " + amount + " successfully");
            System.out.println("UPI Details: UPI Id => " + this.upiId);
        }
    }

    /**
     * Concrete Strategy for PayPal.
     * Encapsulates logic specific to Email/Password authentication.
     */
    static class PayPalStrategy implements PayStrategy {
        private final String email;
        private final String password;

        public PayPalStrategy(String email, String password) {
            this.email = email;
            this.password = password;
        }

        @Override
        public void pay(Double amount) {
            System.out.println("Validating Email: " + this.email + 
                             " and PassWord: " + this.password);
            System.out.println("Paid " + amount + " successfully");
            System.out.println("PayPal Detail: Email => " + this.email + 
                             " Password => " + this.password);
        }
    }

    /**
     * Factory Class.
     * Centralizes the object creation logic, keeping the Client code clean.
     */
    static class PaymentFactory {
        /**
         * Creates and returns the appropriate Strategy object based on the Request Type.
         * @param request The input DTO containing payment details.
         * @return A valid PayStrategy instance.
         */
        public static PayStrategy getStrategy(PaymentRequest request) {
            switch (request.paymentType) {
                case CREDIT_CARD -> {
                    return new CreditCardStrategy(request.cardNumber, 
                                                 request.cvv, request.expiry);
                }
                case UPI -> {
                    return new UPIStrategy(request.upiId);
                }
                case PAYPAL -> {
                    return new PayPalStrategy(request.email, request.password);
                }
                default -> {
                    throw new IllegalArgumentException("Unsupported Payment Type: " + 
                                                      request.paymentType);
                }
            }
        }
    }

    /**
     * Context Class (The Shopping Cart).
     * Maintains a reference to the current Strategy and delegates execution.
     */
    static class PaymentService {
        private PayStrategy strategy;

        /**
         * Allows changing the payment strategy dynamically at runtime.
         */
        public void setStrategy(PayStrategy strategy) {
            this.strategy = strategy;
        }

        /**
         * Executes the payment using the currently selected strategy.
         */
        public void makePayment(Double amount) {
            if(strategy == null) {
                System.out.println("Error: No Payment method selected");
                return;
            }

            System.out.println("\n----Getting Payment Mode-----");
            strategy.pay(amount);
            System.out.println("-------------------------------");
        }
    }

    /**
     * Main method to simulate the User/Client interaction.
     */
    public static void main(String[] args) {
        PaymentService razorPay = new PaymentService();

        System.out.println("Simulation User: Shiv");

        // Scenario 1: Credit Card Payment
        try {
            PaymentRequest request = new PaymentRequest();
            request.paymentType = PaymentType.CREDIT_CARD;
            request.cardNumber = "123456";
            request.cvv = "111";
            request.expiry = "11-2";

            PayStrategy payStrategy = PaymentFactory.getStrategy(request);
            razorPay.setStrategy(payStrategy);
            razorPay.makePayment(100.00);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }

        // Scenario 2: UPI Payment
        try {
            PaymentRequest request = new PaymentRequest();
            request.paymentType = PaymentType.UPI;
            request.upiId = "1234567890";

            PayStrategy payStrategy = PaymentFactory.getStrategy(request);
            razorPay.setStrategy(payStrategy);
            razorPay.makePayment(20.00);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }

        // Scenario 3: PayPal Payment
        try {
            PaymentRequest request = new PaymentRequest();
            request.paymentType = PaymentType.PAYPAL;
            request.email = "noob@gmail.com";
            request.password = "12345678";

            PayStrategy payStrategy = PaymentFactory.getStrategy(request);
            razorPay.setStrategy(payStrategy);
            razorPay.makePayment(50.00);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

Key Features

Strategy Pattern: Encapsulates different payment algorithms
Factory Pattern: Centralizes object creation logic
Type Safety: Uses Enum instead of raw strings
Extensible: Easy to add new payment methods without modifying existing code

LLD-1:Navigation/Route Calculation System

NOOB — Fri, 13 Feb 2026 17:50:39 +0000

Navigation Route Calculation System - Strategy Pattern

This is an implementation of the Strategy design pattern for a navigation system like Google Maps.

Problem Statement

Building a backend for a mapping application where the route calculation algorithm changes based on transport mode. The system must be extensible without rewriting the core engine.

Class Diagram

        +-------------------------------------+             +----------------------------------+
        |             Context                 |             |            Interface             |
        |-------------------------------------|             |----------------------------------|
        |         NavigationService           |             |          RouteStrategy           |
        |-------------------------------------|    HAS-A    |----------------------------------|
        | - strategy: RouteStrategy           |<>---------->| + calculateRoute(src, dest)      |
        | + setStrategy(RouteStrategy)        |             +----------------------------------+
        | + buildRoute(src, dest)             |                              ^
        +-------------------------------------+                              |
                                                                             | IMPLEMENTS
                             +-----------------------------+-----------------+------------------------------+
                             |                             |                                                |
             +-------------------------------+ +-------------------------------+        +-------------------------------+
             |      Concrete Strategy 1      | |      Concrete Strategy 2      |        |      Concrete Strategy 3      |
             |-------------------------------| |-------------------------------|        |-------------------------------|
             |          CarStrategy          | |        WalkingStrategy        |        |    PublicTransportStrategy    |
             +-------------------------------+ +-------------------------------+        +-------------------------------+

Implementation

package com.noob.lld.navigationroutecalculationsystem;

public class NavigationRouteCalculationSystem {

    /**
     * THE STRATEGY INTERFACE
     * This enforces a "Contract". Every navigation algorithm MUST have a
     * calculateRoute method.
     */
    public interface RouteStrategy {
        void calculateRoute(String source, String destination);
    }

    static class CarStrategy implements RouteStrategy {
        @Override
        public void calculateRoute(String source, String destination) {
            System.out.println("[CAR] calculation route....");
            System.out.println("-Avoiding Traffic on Highway 44");
            System.out.println("-ETA: 25 mins. Cost: $2.00 fuel");
            System.out.println("-Route" + source + " => Main Road => " + destination);
        }
    }

    static class WalkingStrategy implements RouteStrategy {
        @Override
        public void calculateRoute(String source, String destination) {
            System.out.println("[WALK] calculation route....");
            System.out.println("-Using shortcut through City Park");
            System.out.println("-ETA: 50 mins. Cost: Free");
            System.out.println("-Route" + source + " => Park Path => " + destination);
        }
    }

    static class PublicTransportStrategy implements RouteStrategy {
        @Override
        public void calculateRoute(String source, String destination) {
            System.out.println("[BUS] calculation route....");
            System.out.println("-Fetching Bus 505 schedule");
            System.out.println("-ETA: 40 mins. Cost: $1.50 ticket");
            System.out.println("-Route" + source + " => Bus Stop A => " + destination);
        }
    }

    static class StrategyFactory {
        public static RouteStrategy getStrategy(String mode) {
            return switch (mode) {
                case "CAR" -> new CarStrategy();
                case "WALK" -> new WalkingStrategy();
                case "BUS" -> new PublicTransportStrategy();
                default -> throw new IllegalArgumentException("Invalid mode: " + mode);
            };
        }
    }

    static class NavigationService {
        private RouteStrategy strategy;

        public void setStrategy(RouteStrategy strategy) {
            this.strategy = strategy;
        }

        public void buildRoute(String source, String destination) {
            if (strategy == null) {
                System.out.println("Error: No transport mode selected");
                return;
            }
            System.out.println("\n----Getting Route----");
            strategy.calculateRoute(source, destination);
            System.out.println("-----------------------");
        }
    }

    public static void main(String[] args) {
        NavigationService googleMaps = new NavigationService();
        String source = "Bangalore Airport";
        String destination = "Samsung R&D";

        // Scenario 1: User selects Car
        String selectedMode = "CAR";
        RouteStrategy strategy = StrategyFactory.getStrategy(selectedMode);
        googleMaps.setStrategy(strategy);
        googleMaps.buildRoute(source, destination);

        // Scenario 2: User switches to Walk
        selectedMode = "WALK";
        strategy = StrategyFactory.getStrategy(selectedMode);
        googleMaps.setStrategy(strategy);
        googleMaps.buildRoute(source, destination);
    }
}