SOLID Principles

SOLID Principles at a Glance

Principle	Description	Mnemonic
SRP	One reason to change	One job per class
OCP	Open for extension, closed for modification	Plug in new features
LSP	Subtypes replace base types	Replaceable children
ISP	Small, focused interfaces	Only what you use
DIP	Depend on abstractions	Use interfaces

Single Responsibility Principle (SRP)

Report

Report
title, content
ReportPrinter
print_report(report)

Each class should have only one reason to change.

(One job per class)

class Report:
    def __init__(self, title, content):
        self.title = title
        self.content = content

class ReportPrinter:
    def print_report(self, report):
        print(f"Title: {report.title}")
        print(f"Content: {report.content}")

class Report {
public:
    std::string title, content;
    Report(const std::string& t, const std::string& c) : title(t), content(c) {}
};

class ReportPrinter {
public:
    void printReport(const Report& report) {
        std::cout << "Title: " << report.title << "\n";
        std::cout << "Content: " << report.content << "\n";
    }
};

Open/Closed Principle (OCP)

Exporters

PDF HTML

ReportExporter
export(report)

Open for extension, closed for modification.

(Add new exporters without changing existing code)

class ReportExporter:
    def export(self, report):
        raise NotImplementedError

class PDFExporter(ReportExporter):
    def export(self, report):
        print(f"Exporting '{report.title}' as PDF...")

class HTMLExporter(ReportExporter):
    def export(self, report):
        print(f"Exporting '{report.title}' as HTML...")

class ReportExporter {
public:
    virtual void exportReport(const Report& report) = 0;
    virtual ~ReportExporter() = default;
};

class PDFExporter : public ReportExporter {
public:
    void exportReport(const Report& report) override {
        std::cout << "Exporting '" << report.title << "' as PDF...\n";
    }
};

class HTMLExporter : public ReportExporter {
public:
    void exportReport(const Report& report) override {
        std::cout << "Exporting '" << report.title << "' as HTML...\n";
    }
};

Liskov Substitution Principle (LSP)

Bird Hierarchy

Bird
fly()
Sparrow
fly()

Subtypes must be substitutable for their base types.

(Replaceable children)

class Bird:
    def fly(self):
        print("Bird is flying")

class Sparrow(Bird):
    def fly(self):
        print("Sparrow is flying")

def make_bird_fly(bird):
    bird.fly()

make_bird_fly(Sparrow())  # Output: Sparrow is flying

class Bird {
public:
    virtual void fly() const {
        std::cout << "Bird is flying\n";
    }
    virtual ~Bird() = default;
};

class Sparrow : public Bird {
public:
    void fly() const override {
        std::cout << "Sparrow is flying\n";
    }
};

void makeBirdFly(const Bird& bird) {
    bird.fly();
}

// Usage:
// Sparrow sparrow;
// makeBirdFly(sparrow); // Output: Sparrow is flying

Interface Segregation Principle (ISP)

Interfaces

Printable
print()
Saveable
save()

Clients should not be forced to depend on methods they do not use.

(Small, focused interfaces)

class Printable:
    def print(self):
        raise NotImplementedError

class Saveable:
    def save(self):
        raise NotImplementedError

class Document(Printable, Saveable):
    def print(self):
        print("Printing document...")

    def save(self):
        print("Saving document...")

class Printable {
public:
    virtual void print() const = 0;
    virtual ~Printable() = default;
};

class Saveable {
public:
    virtual void save() const = 0;
    virtual ~Saveable() = default;
};

class Document : public Printable, public Saveable {
public:
    void print() const override {
        std::cout << "Printing document..." << std::endl;
    }
    void save() const override {
        std::cout << "Saving document..." << std::endl;
    }
};

Dependency Inversion Principle (DIP)

Database Abstraction

Database
connect()
MySQLDatabase
connect()

High-level modules should not depend on low-level modules. Both should depend on abstractions.

(Depend on interfaces, not concrete classes)

class Database:
    def connect(self):
        raise NotImplementedError

class MySQLDatabase(Database):
    def connect(self):
        print("Connecting to MySQL database...")

class AppService:
    def __init__(self, db: Database):
        self.db = db

    def start(self):
        self.db.connect()

# Usage
db = MySQLDatabase()
service = AppService(db)
service.start()

class Database {
public:
    virtual void connect() const = 0;
    virtual ~Database() = default;
};

class MySQLDatabase : public Database {
public:
    void connect() const override {
        std::cout << "Connecting to MySQL database..." << std::endl;
    }
};

class AppService {
    const Database& db;
public:
    AppService(const Database& database) : db(database) {}
    void start() const {
        db.connect();
    }
};

// Usage:
// MySQLDatabase db;
// AppService service(db);
// service.start();