LLD: SOLID & Design Patterns

# S - Single Responsibility Principle
? Har class ka ek hi responsibility hona chahiye
? Bad: User class jo data bhi store karti hai aur email bhi bhejti hai
? Good: User class (data) + EmailService (email)

# O - Open/Closed Principle
? Open for extension, closed for modification
? Bad: Har naye payment type ke liye Payment class modify karo
? Good: Payment interface + CreditCardPayment, UPIPayment, etc.

# L - Liskov Substitution Principle
? Derived classes base class ko replace kar sakein
? Bad: Square class inherits Rectangle but width/height alag behave kare
? Good: Dono alag se implement karo

# I - Interface Segregation Principle
? Chhote-chhote specific interfaces banao, ek bada interface nahi
? Bad: Animal interface — fly(), swim(), walk() (sab animals nahi kar paate)
? Good: Flyable, Swimmable, Walkable interfaces

# D - Dependency Inversion Principle
? High-level modules low-level modules pe depend nahi karte
? Dono abstractions pe depend karte hain
? Bad: OrderService directly MySQL database use kare
? Good: OrderService depends on Database interface (abstraction)

# 1. Singleton Pattern
? Ek hi instance of class exist kare
? Database connection, Logger

class Database:
 _instance = None
 
 @staticmethod
 def get_instance():
 if Database._instance is None:
 Database._instance = Database()
 return Database._instance

# 2. Factory Pattern
? Object creation logic encapsulate karo
? Client ko pata nahi kaunsi class instantiate ho rahi

class PaymentFactory:
 @staticmethod
 def create_payment(method):
 if method == "credit_card":
 return CreditCardPayment()
 elif method == "upi":
 return UPIPayment()

# 3. Builder Pattern
? Complex objects step-by-step build karo
? Telescoping constructor se bacho

query = (QueryBuilder()
 .select("name", "email")
 .from_table("users")
 .where("age > 18")
 .order_by("name")
 .build())

# 1. Adapter Pattern
? Incompatible interfaces ko compatible banao
? Legacy system integrate karna ho

class OldPaymentSystem:
 def make_payment_legacy(self, amt):
 return f"Paid {amt}"

class PaymentAdapter:
 def __init__(self, old_system):
 self.old_system = old_system
 
 def pay(self, amount):
 return self.old_system.make_payment_legacy(amount)

# 2. Decorator Pattern
? Behavior dynamically add/remove karo
? Inheritance se

class Coffee:
 def cost(self): return 50

class MilkDecorator:
 def __init__(self, coffee):
 self.coffee = coffee
 def cost(self):
 return self.coffee.cost() + 20

# Usage: MilkDecorator(Coffee()) — cost = 70

# 3. Proxy Pattern
? Real object ki jagah proxy use karo
? Caching, lazy loading, access control

class RealImage:
 def display(self):
 print("Displaying image")

class ProxyImage:
 def __init__(self, filename):
 self.filename = filename
 self.real_image = None
 
 def display(self):
 if self.real_image is None:
 self.real_image = RealImage() # lazy load
 self.real_image.display()

# 1. Observer Pattern
? Ek change ho toh saare dependents ko notify karo
? Event-driven systems

class EventEmitter:
 def __init__(self):
 self.listeners = {}
 
 def on(self, event, callback):
 self.listeners.setdefault(event, []).append(callback)
 
 def emit(self, event, data):
 for cb in self.listeners.get(event, []):
 cb(data)

# 2. Strategy Pattern
? Algorithm ka behavior runtime pe change karo
? Multiple strategies, client choose kare

class SortStrategy:
 def sort(self, data): pass

class QuickSort(SortStrategy):
 def sort(self, data): return quicksort(data)

class MergeSort(SortStrategy):
 def sort(self, data): return mergesort(data)

class Sorter:
 def __init__(self, strategy):
 self.strategy = strategy
 def sort(self, data):
 return self.strategy.sort(data)

# 3. State Pattern
? Object ka behavior uske state ke hisaab se change
? Finite state machines

class OrderState:
 def next(self, order): pass
 def status(self): pass

class NewOrder(OrderState):
 def next(self, order):
 order.state = ProcessingOrder()
 def status(self): return "New"

class ProcessingOrder(OrderState):
 def next(self, order):
 order.state = ShippedOrder()
 def status(self): return "Processing"