Master Low Level

Design (LLD)

public class DatabaseConnection {
    // volatile ensures visibility across threads
    private static volatile DatabaseConnection instance = null;

    // Private constructor — no one can create it from outside
    private DatabaseConnection() {
        // Expensive initialization: connect to DB, setup pools...
        System.out.println("DB Connection established");
    }

    // Double-checked locking for thread safety
    public static DatabaseConnection getInstance() {
        if (instance == null) {
            synchronized (DatabaseConnection.class) {
                if (instance == null) {
                    instance = new DatabaseConnection();
                }
            }
        }
        return instance;
    }

    public void query(String sql) { /* execute query */ }
}

// Usage
DatabaseConnection db1 = DatabaseConnection.getInstance();
DatabaseConnection db2 = DatabaseConnection.getInstance();
// db1 == db2 → ALWAYS TRUE

interface Notification {
    void send(String message);
}

class EmailNotification implements Notification {
    @Override
    public void send(String message) {
        System.out.println("📧 Email: " + message);
    }
}

class SMSNotification implements Notification {
    @Override
    public void send(String message) {
        System.out.println("📱 SMS: " + message);
    }
}

class PushNotification implements Notification {
    @Override
    public void send(String message) {
        System.out.println("🔔 Push: " + message);
    }
}

// The Factory — knows which object to create
class NotificationFactory {
    public static Notification create(String type) {
        switch (type.toLowerCase()) {
            case "email": return new EmailNotification();
            case "sms":   return new SMSNotification();
            case "push":  return new PushNotification();
            default: throw new IllegalArgumentException("Unknown type: " + type);
        }
    }
}

// Client code
Notification n = NotificationFactory.create("email");
n.send("Your order has shipped!");

public class Pizza {
    private String size;
    private String crust;
    private String sauce;
    private List<String> toppings;
    private boolean extraCheese;

    // Private — only Builder can create this
    private Pizza(Builder builder) {
        this.size = builder.size;
        this.crust = builder.crust;
        this.sauce = builder.sauce;
        this.toppings = builder.toppings;
        this.extraCheese = builder.extraCheese;
    }

    public static class Builder {
        private String size;
        private String crust = "thin";  // defaults
        private String sauce = "tomato";
        private List<String> toppings = new ArrayList<>();
        private boolean extraCheese = false;

        public Builder(String size) { this.size = size; }

        public Builder crust(String crust) { this.crust = crust; return this; }
        public Builder sauce(String sauce) { this.sauce = sauce; return this; }
        public Builder topping(String t) { toppings.add(t); return this; }
        public Builder extraCheese() { this.extraCheese = true; return this; }
        public Pizza build() { return new Pizza(this); }
    }
}

// Clean, readable object creation!
Pizza myPizza = new Pizza.Builder("large")
    .crust("thick")
    .sauce("bbq")
    .topping("pepperoni")
    .topping("mushrooms")
    .extraCheese()
    .build();

// Your code expects this interface
interface MediaPlayer {
    void play(String filename);
}

// But you have this third-party library with different interface
class VlcPlayer {
    public void playVlc(String filename) {
        System.out.println("VLC playing: " + filename);
    }
}

// Adapter bridges the gap
class VlcAdapter implements MediaPlayer {
    private VlcPlayer vlcPlayer;

    public VlcAdapter(VlcPlayer player) { this.vlcPlayer = player; }

    @Override
    public void play(String filename) {
        vlcPlayer.playVlc(filename);  // translates the call
    }
}

// Client uses MediaPlayer interface — doesn't know about VLC!
MediaPlayer player = new VlcAdapter(new VlcPlayer());
player.play("movie.vlc");

interface Coffee {
    String getDescription();
    double getCost();
}

class Espresso implements Coffee {
    @Override public String getDescription() { return "Espresso"; }
    @Override public double getCost() { return 1.99; }
}

// Abstract decorator — wraps a Coffee
abstract class CoffeeDecorator implements Coffee {
    protected Coffee coffee;
    public CoffeeDecorator(Coffee c) { this.coffee = c; }
}

class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee c) { super(c); }

    @Override
    public String getDescription() { return coffee.getDescription() + ", Milk"; }
    @Override
    public double getCost() { return coffee.getCost() + 0.50; }
}

class CaramelDecorator extends CoffeeDecorator {
    public CaramelDecorator(Coffee c) { super(c); }

    @Override
    public String getDescription() { return coffee.getDescription() + ", Caramel"; }
    @Override
    public double getCost() { return coffee.getCost() + 0.75; }
}

// Stacking decorators!
Coffee myCoffee = new Espresso();
myCoffee = new MilkDecorator(myCoffee);
myCoffee = new CaramelDecorator(myCoffee);

System.out.println(myCoffee.getDescription()); // Espresso, Milk, Caramel
System.out.println("$" + myCoffee.getCost());   // $3.24

interface Observer {
    void update(String event, Object data);
}

interface Subject {
    void subscribe(Observer observer);
    void unsubscribe(Observer observer);
    void notifyObservers(String event, Object data);
}

class OrderService implements Subject {
    private List<Observer> observers = new ArrayList<>();

    @Override public void subscribe(Observer o) { observers.add(o); }
    @Override public void unsubscribe(Observer o) { observers.remove(o); }

    @Override
    public void notifyObservers(String event, Object data) {
        for (Observer o : observers) o.update(event, data);
    }

    public void placeOrder(Order order) {
        // ... process order logic ...
        notifyObservers("ORDER_PLACED", order); // broadcast!
    }
}

// Multiple independent observers react to the same event
class EmailNotifier implements Observer {
    @Override
    public void update(String event, Object data) {
        if ("ORDER_PLACED".equals(event))
            System.out.println("Sending confirmation email...");
    }
}

class InventoryManager implements Observer {
    @Override
    public void update(String event, Object data) {
        if ("ORDER_PLACED".equals(event))
            System.out.println("Updating inventory...");
    }
}

interface SortStrategy {
    void sort(int[] array);
}

class BubbleSort implements SortStrategy {
    @Override
    public void sort(int[] arr) {
        // O(n²) — good for small arrays
        System.out.println("Bubble sorting...");
    }
}

class QuickSort implements SortStrategy {
    @Override
    public void sort(int[] arr) {
        // O(n log n) average — good for large arrays
        System.out.println("Quick sorting...");
    }
}

// Context — uses a strategy
class DataSorter {
    private SortStrategy strategy;

    public DataSorter(SortStrategy strategy) { this.strategy = strategy; }

    // Can switch strategy at runtime!
    public void setStrategy(SortStrategy s) { this.strategy = s; }

    public void performSort(int[] data) {
        strategy.sort(data);
    }
}

// Usage
DataSorter sorter = new DataSorter(new BubbleSort());
sorter.performSort(smallArray);

sorter.setStrategy(new QuickSort());  // switch at runtime!
sorter.performSort(largeArray);