Low-Level Design Interview Guide: OOP, SOLID & Design Patterns with Examples

// VIOLATION: Adding a new payment method modifies existing class (violates OCP)
class PaymentProcessorBad {
  process(type: string, amount: number) {
    if (type === "CREDIT_CARD") { /* charge card */ }
    else if (type === "PAYPAL") { /* charge paypal */ }
    else if (type === "CRYPTO") { /* charge crypto */ }
    else throw new Error("Unsupported payment type");
  }
}

// REMEDIATION: Extensible Strategy Pattern adhering to OCP and DIP
interface PaymentStrategy {
  pay(amount: number): Promise<PaymentReceipt>;
}

class CreditCardPayment implements PaymentStrategy {
  constructor(private cardNumber: string, private cvv: string) {}
  async pay(amount: number): Promise<PaymentReceipt> {
    // Isolated credit card execution logic
    return { status: "SUCCESS", transactionId: "CC-9821", amount };
  }
}

class UPIPayment implements PaymentStrategy {
  constructor(private vpaId: string) {}
  async pay(amount: number): Promise<PaymentReceipt> {
    // Isolated UPI execution logic
    return { status: "SUCCESS", transactionId: "UPI-4412", amount };
  }
}

// Client remains untouched when new payment strategies are introduced
class CheckoutService {
  constructor(private paymentStrategy: PaymentStrategy) {}

  async completeOrder(cartTotal: number) {
    return await this.paymentStrategy.pay(cartTotal);
  }
}

// Method 1: Bill Pugh Initialization-on-Demand Holder (Recommended for Classes)
public class DatabaseConnectionPool {
    private DatabaseConnectionPool() {
        // Prevent reflection instantiation attack
        if (InstanceHolder.INSTANCE != null) {
            throw new IllegalStateException("Already initialized");
        }
    }

    private static class InstanceHolder {
        // Class loaded only when getInstance() is called; JVM guarantees thread safety
        private static final DatabaseConnectionPool INSTANCE = new DatabaseConnectionPool();
    }

    public static DatabaseConnectionPool getInstance() {
        return InstanceHolder.INSTANCE;
    }
}

// Method 2: Java Enum Singleton (Guaranteed serialization-safe & thread-safe)
public enum ConfigurationManager {
    INSTANCE;

    private final Map<String, String> configs = new ConcurrentHashMap<>();

    public String getProperty(String key) {
        return configs.get(key);
    }

    public void setProperty(String key, String value) {
        configs.put(key, value);
    }
}

export enum VehicleType { MOTORBIKE, CAR, TRUCK }
export enum SpotType { TWO_WHEELER, COMPACT, LARGE }

export class Vehicle {
  constructor(public licensePlate: string, public type: VehicleType) {}
}

export class ParkingSpot {
  private occupiedVehicle: Vehicle | null = null;
  constructor(public id: string, public floor: number, public type: SpotType) {}

  isAvailable(): boolean { return this.occupiedVehicle === null; }
  park(v: Vehicle) { this.occupiedVehicle = v; }
  unpark() { this.occupiedVehicle = null; }
  getVehicle() { return this.occupiedVehicle; }
}

export interface SpotAllocationStrategy {
  findSpot(spots: ParkingSpot[], vehicle: Vehicle): ParkingSpot | null;
}

export class NearestFirstStrategy implements SpotAllocationStrategy {
  findSpot(spots: ParkingSpot[], vehicle: Vehicle): ParkingSpot | null {
    return spots.find(s => s.isAvailable() && this.canFit(s.type, vehicle.type)) || null;
  }

  private canFit(spotType: SpotType, vehicleType: VehicleType): boolean {
    if (vehicleType === VehicleType.MOTORBIKE) return true;
    if (vehicleType === VehicleType.CAR) return spotType !== SpotType.TWO_WHEELER;
    if (vehicleType === VehicleType.TRUCK) return spotType === SpotType.LARGE;
    return false;
  }
}

export class ParkingLotManager {
  private spots: ParkingSpot[] = [];
  constructor(private allocationStrategy: SpotAllocationStrategy) {}

  addSpot(spot: ParkingSpot) { this.spots.push(spot); }

  parkVehicle(vehicle: Vehicle): ParkingSpot {
    const spot = this.allocationStrategy.findSpot(this.spots, vehicle);
    if (!spot) throw new Error("Parking Lot Full for vehicle type " + vehicle.type);
    spot.park(vehicle);
    return spot;
  }
}

public class ConcurrentLRUCache<K, V> {
    private final int capacity;
    private final Map<K, Node<K, V>> map;
    private final DoublyLinkedList<K, V> list;
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

    public ConcurrentLRUCache(int capacity) {
        this.capacity = capacity;
        this.map = new HashMap<>();
        this.list = new DoublyLinkedList<>();
    }

    public V get(K key) {
        rwLock.writeLock().lock(); // Write lock needed because LRU order updates on read!
        try {
            Node<K, V> node = map.get(key);
            if (node == null) return null;
            list.moveToHead(node);
            return node.value;
        } finally {
            rwLock.writeLock().unlock();
        }
    }

    public void put(K key, V value) {
        rwLock.writeLock().lock();
        try {
            if (map.containsKey(key)) {
                Node<K, V> node = map.get(key);
                node.value = value;
                list.moveToHead(node);
            } else {
                if (map.size() >= capacity) {
                    Node<K, V> evicted = list.removeTail();
                    map.remove(evicted.key);
                }
                Node<K, V> newNode = new Node<>(key, value);
                list.addToHead(newNode);
                map.put(key, newNode);
            }
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}