Object-oriented design principles in LLD - System Design Exercise

Design: Object-oriented Design Principles

In scope: Explanation and demonstration of the five main OOD principles (SRP, OCP, LSP, ISP, DIP) with simple examples. Out of scope: Detailed language-specific syntax or advanced design patterns.

Functional Requirements

FR1: Explain the core principles of object-oriented design (OOD).

FR2: Demonstrate how these principles improve software design quality.

FR3: Show examples of applying these principles in a simple system.

FR4: Ensure the design supports easy maintenance and scalability.

Non-Functional Requirements

NFR1: Design must be understandable by beginners.

NFR2: Use simple, relatable examples.

NFR3: Focus on principles, not specific programming languages.

NFR4: Avoid complex jargon or advanced patterns.

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

Key Components

Classes and objects

Interfaces or abstract classes

Modules or packages

Dependencies between components

Design Patterns

Single Responsibility Principle (SRP)

Open/Closed Principle (OCP)

Liskov Substitution Principle (LSP)

Interface Segregation Principle (ISP)

Dependency Inversion Principle (DIP)

Reference Architecture

  +---------------------+       +---------------------+
  |      Client         |       |    Service Layer    |
  +---------------------+       +---------------------+
             |                             |
             | uses                        | depends on
             v                             v
  +---------------------+       +---------------------+
  |   Interface / API   |<----->|  Implementation Class|
  +---------------------+       +---------------------+
             ^                             |
             |                             |
       depends on                    depends on
             |                             |
  +---------------------+       +---------------------+
  |   Abstract Classes   |       |  Concrete Classes    |
  +---------------------+       +---------------------+

Components

Client

Conceptual

Uses the system through interfaces, demonstrating dependency inversion.

Interface / API

Abstract Interface

Defines contracts for classes, supporting ISP and DIP.

Implementation Class

Concrete Class

Implements interfaces, following SRP and OCP.

Abstract Classes

Abstract Base Classes

Provide base functionality and support LSP.

Concrete Classes

Concrete Classes

Extend abstract classes and implement interfaces, adhering to all principles.

Request Flow

1. 1. Client calls a method on an interface, not a concrete class (DIP).

2. 2. The interface defines the expected behavior (ISP).

3. 3. Concrete classes implement the interface, each with a single responsibility (SRP).

4. 4. New features are added by extending classes without modifying existing code (OCP).

5. 5. Subtypes can replace base types without breaking the system (LSP).

Database Schema

Not applicable as this is a design principles concept focusing on class relationships and dependencies.

Scaling Discussion

Bottlenecks

Tight coupling between classes making changes risky.

Large classes violating SRP causing maintenance issues.

Interfaces that are too broad violating ISP.

Inheritance hierarchies that break LSP causing unexpected behavior.

Direct dependencies on concrete classes violating DIP.

Solutions

Use interfaces and abstractions to reduce coupling.

Split classes to ensure each has a single responsibility.

Create focused interfaces tailored to client needs.

Design inheritance carefully to ensure substitutability.

Depend on abstractions rather than concrete implementations.

Interview Tips

Time: Spend 10 minutes explaining each principle with simple examples, 10 minutes discussing how they work together, and 5 minutes answering questions.

Explain each principle clearly and simply.

Show how principles improve code quality and maintainability.

Use relatable examples to illustrate concepts.

Discuss trade-offs and real-world application.

Highlight how principles reduce bugs and ease scaling.