SOLID Principle in software design example

These slides explained 5 principle of software design.

1. DESIGN PRINCIPLES AND PATTERNS SOLID PRINCIPLES

2. SOLID Principles

3. Single Responsibilty Principle(SRP) This principle states that " A class should have only one reason to change " which means every class should have a single responsibility or single job or single purpose. Example : Each worker has one clear job (painter paints, plumber plumbs).

4. A single practical project example (like an e-commerce app) # ✅ S: Single Responsibility Principle # Separate responsibilities: Product handles data, Invoice handles billing class Product: def __init__(self, name: str, price: float): self.name = name self.price = price class Invoice: def __init__(self, products: list[Product]): self.products = products def calculate_total(self): return sum(p.price for p in self.products)

5. Open-Closed Principle(OCP) This principle states that " Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification " which means you should be able to extend a class behavior, without modifying it. Example : The house should allow extensions (adding a new room) but not require breaking walls.

6. A single practical project example (like an e-commerce app) # ✅ O: Open/Closed Principle # Payment method can be extended without changing existing code from abc import abstract method class Payment(ABC): @abstractmethod def pay(self, amount: float): pass class CreditCardPayment(Payment): def pay(self, amount: float): print(f"Paid ₹{amount} using Credit Card") class PayPalPayment(Payment): def pay(self, amount: float): print(f"Paid ₹{amount} using PayPal")

7. Liskov's Substitution Principle(LSP) The principle was introduced by Barbara Liskov in 1987 and according to this principle "Derived or child classes must be sustainable for their base or parent classes". This principle ensures that any class that is the child of a parent class should be usable in place of its parent without any unexpected behavior. Example : If you replace an electrician with another certified electrician, the work still goes smoothly.

8. A single practical project example (like an e-commerce app) # ✅ L: Liskov Substitution Principle # Any new payment method can replace another without breaking functionality def process_payment(payment: Payment, amount: float): payment_pay(amount)

9.   Interface Segregation Principle(ISP) It states that " do not force any client to implement an interface which is irrelevant to them ".  Example : Don’t force a worker to carry tools they don’t need (painter doesn’t need plumbing tools).

10. A single practical project example (like an e-commerce app) # ✅ I: Interface Segregation Principle # Separate interfaces for different order operations class OrderSaver(ABC): @abstractmethod def save(self, invoice: Invoice): pass class DatabaseOrderSaver(OrderSaver): def save(self, invoice: Invoice): print("Order saved to database")

11.   Dependency Inversion Principle(DIP) The Dependency Inversion Principle (DIP) is a principle in object-oriented design that states that "High-level modules should not depend on low-level modules. Both should depend on abstractions". Example : The house design depends on blueprints (abstractions), not specific workers. In a software development team, developers depend on an abstract version control system ( e.g., Git ) to manage and track changes to the codebase. They don't depend on specific details of how Git works internally .

12. A single practical project example (like an e-commerce app) # ✅ D: Dependency Inversion Principle # High-level OrderService depends on abstract interfaces, not concrete classes class OrderService: def __init__(self, saver: OrderSaver, payment: Payment): self.saver = saver self.emailer = emailer self.payment = payment def place_order(self, invoice: Invoice): amount = invoice.calculate_total() self.payment.pay(amount) self.saver.save(invoice) print("Order successfully placed!")

13. A single practical project example (like an e-commerce app) if __name__ == "__main__": # Products p1 = Product("Laptop", 60000) p2 = Product("Mouse", 1500) invoice = Invoice([p1, p2]) # Place Order order_service = OrderService( saver=DatabaseOrderSaver(), emailer=EmailOrderNotifier(), payment=CreditCardPayment() ) order_service.place_order(invoice) # Try with another payment method order_service = OrderService( saver=DatabaseOrderSaver(), payment=PayPalPayment() ) order_service.place_order(invoice)

14. Summary