Open Closed Principle

Open Closed Principle

The Open Closed Principle (also known as OCP or OCP principle) is one of the five SOLID principles of object-oriented design. The Open Closed Principle (sometimes written as open-closed principle or open/closed principle) states that software entities (classes, modules, functions, etc.) should be open for extension but closed for modification. This means you should be able to add new functionality without changing existing code.

In simple terms, whenever we design a class, we need to carefully encapsulate the implementation details so that it has good maintainability. We want it to be open to extension but closed to modification. Understanding the Open Closed Principle is essential for building maintainable, scalable software systems.

Open Closed Principle Example

Let’s look at a practical Open Closed Principle example to understand how it works in real-world scenarios.

Understanding the Principle

The behavior of a module can be extended without modifying its source code. This is typically achieved through mechanisms such as:

• Inheritance - Creating subclasses
• Interfaces - Implementing contracts
• Composition - Combining objects

Example: Notification System

Consider a notification system where you need to send alerts through different channels. Instead of modifying the core notification logic every time you add a new channel, you can extend it through inheritance.

Violating OCP (Bad Approach)

💡 Tip: Click dropdown to switch between languages

Python

Python

bad_notifications.py

class NotificationService:
    def send_notification(self, channel: str, message: str):
        if channel == "email":
            print(f"Sending email: {message}")
        elif channel == "slack":
            print(f"Posting to Slack: {message}")
        elif channel == "teams":
            print(f"Sending Teams message: {message}")
        # ❌ Must modify this class to add new channels!

Java

BadNotificationService.java

public class NotificationService {
    public void sendNotification(String channel, String message) {
        if ("email".equals(channel)) {
            System.out.println("Sending email: " + message);
        } else if ("slack".equals(channel)) {
            System.out.println("Posting to Slack: " + message);
        } else if ("teams".equals(channel)) {
            System.out.println("Sending Teams message: " + message);
        }
        // ❌ Must modify this class to add new channels!
    }
}

TypeScript

bad-notifications.ts

class NotificationService {
    sendNotification(channel: string, message: string): void {
        if (channel === "email") {
            console.log(`Sending email: ${message}`);
        } else if (channel === "slack") {
            console.log(`Posting to Slack: ${message}`);
        } else if (channel === "teams") {
            console.log(`Sending Teams message: ${message}`);
        }
        // ❌ Must modify this class to add new channels!
    }
}

C++

BadNotificationService.cpp

#include <string>
#include <iostream>

class NotificationService {
public:
    void sendNotification(const std::string& channel, const std::string& message) {
        if (channel == "email") {
            std::cout << "Sending email: " << message << std::endl;
        } else if (channel == "slack") {
            std::cout << "Posting to Slack: " << message << std::endl;
        } else if (channel == "teams") {
            std::cout << "Sending Teams message: " << message << std::endl;
        }
        // ❌ Must modify this class to add new channels!
    }
};

C#

BadNotificationService.cs

using System;

public class NotificationService
{
    public void SendNotification(string channel, string message)
    {
        if (channel == "email")
        {
            Console.WriteLine($"Sending email: {message}");
        }
        else if (channel == "slack")
        {
            Console.WriteLine($"Posting to Slack: {message}");
        }
        else if (channel == "teams")
        {
            Console.WriteLine($"Sending Teams message: {message}");
        }
        // ❌ Must modify this class to add new channels!
    }
}

Go

bad_notification_service.go

package main

import "fmt"

type NotificationService struct{}

func (s *NotificationService) SendNotification(channel, message string) {
  if channel == "email" {
    fmt.Printf("Sending email: %s\n", message)
  } else if channel == "slack" {
    fmt.Printf("Posting to Slack: %s\n", message)
  } else if channel == "teams" {
    fmt.Printf("Sending Teams message: %s\n", message)
  }
  // ❌ Must modify this struct to add new channels!
}

Rust

bad_notification_service.rs

enum NotificationType {
    Email,
    Sms,
}
struct NotificationService;
impl NotificationService {
    fn send(&self, kind: NotificationType, message: &str) {
        match kind {
            NotificationType::Email => println!("Email: {message}"),
            NotificationType::Sms => println!("SMS: {message}"),
        }
    }
}
// Adding a channel requires editing this match.

Violation Warning

Every time you need to add a new notification channel, you must modify the NotificationService class. This violates OCP because:

• You’re changing existing, tested code
• Risk of introducing bugs in working functionality
• The class keeps growing and becoming harder to maintain

Following OCP (Good Approach)

💡 Tip: Click dropdown to switch between languages

Python

Python

notifications.py

class Notification:
    def send(self, message: str):
        """Base method - closed for modification"""
        pass

class EmailNotification(Notification):
    def __init__(self, recipient: str):
        self.recipient = recipient

    def send(self, message: str):
        print(f"Sending email to {self.recipient}: {message}")

class SlackNotification(Notification):
    def __init__(self, channel: str):
        self.channel = channel

    def send(self, message: str):
        print(f"Posting to Slack #{self.channel}: {message}")

Java

Notification.java

// Base class - closed for modification
public abstract class Notification {
    public abstract void send(String message);
}

public class EmailNotification extends Notification {
    private String recipient;

    public EmailNotification(String recipient) {
        this.recipient = recipient;
    }

    @Override
    public void send(String message) {
        System.out.println("Sending email to " + recipient + ": " + message);
    }
}

public class SlackNotification extends Notification {
    private String channel;

    public SlackNotification(String channel) {
        this.channel = channel;
    }

    @Override
    public void send(String message) {
        System.out.println("Posting to Slack #" + channel + ": " + message);
    }
}

TypeScript

notifications.ts

// Base class - closed for modification
abstract class Notification {
    abstract send(message: string): void;
}

class EmailNotification extends Notification {
    constructor(private recipient: string) {
        super();
    }

    send(message: string): void {
        console.log(`Sending email to ${this.recipient}: ${message}`);
    }
}

class SlackNotification extends Notification {
    constructor(private channel: string) {
        super();
    }

    send(message: string): void {
        console.log(`Posting to Slack #${this.channel}: ${message}`);
    }
}

C++

Notification.cpp

#include <string>
#include <iostream>

// Base class - closed for modification
class Notification {
public:
    virtual ~Notification() = default;
    virtual void send(const std::string& message) = 0;
};

class EmailNotification : public Notification {
private:
    std::string recipient;

public:
    EmailNotification(const std::string& recipient)
        : recipient(recipient) {}

    void send(const std::string& message) override {
        std::cout << "Sending email to " << recipient << ": " << message << std::endl;
    }
};

class SlackNotification : public Notification {
private:
    std::string channel;

public:
    SlackNotification(const std::string& channel)
        : channel(channel) {}

    void send(const std::string& message) override {
        std::cout << "Posting to Slack #" << channel << ": " << message << std::endl;
    }
};

C#

Notification.cs

using System;

// Base class - closed for modification
public abstract class Notification
{
    public abstract void Send(string message);
}

public class EmailNotification : Notification
{
    private string recipient;

    public EmailNotification(string recipient)
    {
        this.recipient = recipient;
    }

    public override void Send(string message)
    {
        Console.WriteLine($"Sending email to {recipient}: {message}");
    }
}

public class SlackNotification : Notification
{
    private string channel;

    public SlackNotification(string channel)
    {
        this.channel = channel;
    }

    public override void Send(string message)
    {
        Console.WriteLine($"Posting to Slack #{channel}: {message}");
    }
}

Go

notification.go

package main

import "fmt"

// Base abstraction - closed for modification
type Notification interface {
  Send(message string)
}

type EmailNotification struct{ recipient string }

func NewEmailNotification(recipient string) *EmailNotification {
  return &EmailNotification{recipient: recipient}
}

func (n *EmailNotification) Send(message string) {
  fmt.Printf("Sending email to %s: %s\n", n.recipient, message)
}

type SlackNotification struct{ channel string }

func NewSlackNotification(channel string) *SlackNotification {
  return &SlackNotification{channel: channel}
}

func (n *SlackNotification) Send(message string) {
  fmt.Printf("Posting to Slack #%s: %s\n", n.channel, message)
}

Rust

notification.rs

trait Notification {
    fn send(&self, message: &str);
}
struct EmailNotification;
struct SmsNotification;
impl Notification for EmailNotification {
    fn send(&self, message: &str) {
        println!("Email: {message}");
    }
}
impl Notification for SmsNotification {
    fn send(&self, message: &str) {
        println!("SMS: {message}");
    }
}
struct NotificationService;
impl NotificationService {
    fn send(&self, n: &dyn Notification, message: &str) {
        n.send(message);
    }
}

Adding New Functionality

If you need to add a new notification channel (like Teams or SMS), you can create a new subclass without touching the existing code:

💡 Tip: Click dropdown to switch between languages

Python

Python

notifications.py

class TeamsNotification(Notification):
    def __init__(self, team: str):
        self.team = team

    def send(self, message: str):
        print(f"Sending Teams message to {self.team}: {message}")

# Usage
teams_notification = TeamsNotification("Engineering")
teams_notification.send("Deployment successful!")

Java

TeamsNotification.java

public class TeamsNotification extends Notification {
    private String team;

    public TeamsNotification(String team) {
        this.team = team;
    }

    @Override
    public void send(String message) {
        System.out.println("Sending Teams message to " + team + ": " + message);
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        TeamsNotification teamsNotification = new TeamsNotification("Engineering");
        teamsNotification.send("Deployment successful!");
    }
}

TypeScript

notifications.ts

class TeamsNotification extends Notification {
    constructor(private team: string) {
        super();
    }

    send(message: string): void {
        console.log(`Sending Teams message to ${this.team}: ${message}`);
    }
}

// Usage
const teamsNotification = new TeamsNotification("Engineering");
teamsNotification.send("Deployment successful!");

C++

TeamsNotification.cpp

#include <string>
#include <iostream>

class TeamsNotification : public Notification {
private:
    std::string team;

public:
    TeamsNotification(const std::string& team)
        : team(team) {}

    void send(const std::string& message) override {
        std::cout << "Sending Teams message to " << team << ": " << message << std::endl;
    }
};

// Usage
int main() {
    TeamsNotification teamsNotification("Engineering");
    teamsNotification.send("Deployment successful!");
    return 0;
}

C#

TeamsNotification.cs

using System;

public class TeamsNotification : Notification
{
    private string team;

    public TeamsNotification(string team)
    {
        this.team = team;
    }

    public override void Send(string message)
    {
        Console.WriteLine($"Sending Teams message to {team}: {message}");
    }
}

// Usage
class Program
{
    static void Main()
    {
        TeamsNotification teamsNotification = new TeamsNotification("Engineering");
        teamsNotification.Send("Deployment successful!");
    }
}

Go

teams_notification.go

package main

import "fmt"

type TeamsNotification struct{ team string }

func NewTeamsNotification(team string) *TeamsNotification {
  return &TeamsNotification{team: team}
}

func (n *TeamsNotification) Send(message string) {
  fmt.Printf("Sending Teams message to %s: %s\n", n.team, message)
}

func main() {
  teams := NewTeamsNotification("Engineering")
  teams.Send("Deployment successful!")
}

Rust

teams_notification.rs

trait Notification {
    fn send(&self, message: &str);
}
struct TeamsNotification;
impl Notification for TeamsNotification {
    fn send(&self, message: &str) {
        println!("Teams: {message}");
    }
}
fn notify(notification: &dyn Notification) {
    notification.send("Deployment finished");
}
// New functionality is an extension.

Benefits of Following OCP

Why OCP Matters

Following OCP provides significant advantages:

1. Reduced Risk - Existing code remains untouched, reducing the chance of introducing bugs
2. Better Maintainability - Changes are isolated to new code
3. Easier Testing - New functionality can be tested independently
4. Improved Scalability - Easy to add new features without affecting existing ones

Handling Scenarios Where Modification Might Be Necessary

While OCP encourages extension over modification, there are scenarios where modification is unavoidable or where alternative approaches are needed:

1. Third-Party Classes (Using Adapter Pattern)

When working with external libraries or sealed classes that cannot be extended, use composition and adapters instead.

Problem: You’re using a third-party notification library that you cannot modify:

💡 Tip: Click dropdown to switch between languages

Python

Python

third_party_lib.py

# This is from an external library - you cannot modify it
class ThirdPartyEmailService:
    def send_email(self, to: str, subject: str, body: str):
        print(f"Third-party service sending email to {to}")
        # Actual implementation...

Java

ThirdPartyEmailService.java

// This is from an external library - you cannot modify it
public class ThirdPartyEmailService {
    public void sendEmail(String to, String subject, String body) {
        System.out.println("Third-party service sending email to " + to);
        // Actual implementation...
    }
}

TypeScript

third-party-lib.ts

// This is from an external library - you cannot modify it
class ThirdPartyEmailService {
    sendEmail(to: string, subject: string, body: string): void {
        console.log(`Third-party service sending email to ${to}`);
        // Actual implementation...
    }
}

C++

ThirdPartyEmailService.cpp

#include <string>
#include <iostream>

// This is from an external library - you cannot modify it
class ThirdPartyEmailService {
public:
    void sendEmail(const std::string& to, const std::string& subject,
                   const std::string& body) {
        std::cout << "Third-party service sending email to " << to << std::endl;
        // Actual implementation...
    }
};

C#

ThirdPartyEmailService.cs

using System;

// This is from an external library - you cannot modify it
public class ThirdPartyEmailService
{
    public void SendEmail(string to, string subject, string body)
    {
        Console.WriteLine($"Third-party service sending email to {to}");
        // Actual implementation...
    }
}

Go

third_party_email_service.go

package main

import "fmt"

// This is from an external library - you cannot modify it
type ThirdPartyEmailService struct{}

func (s *ThirdPartyEmailService) SendEmail(to, subject, body string) {
  fmt.Printf("Third-party service sending email to %s\n", to)
  // Actual implementation...
}

Rust

third_party_email_service.rs

struct ThirdPartyEmailService;
impl ThirdPartyEmailService {
    fn send_email(&self, to: &str, subject: &str, body: &str) {
        println!("Third-party email to {to}: {subject} - {body}");
    }
}
// External API does not match our Notification abstraction.

Solution: Create an adapter/wrapper class that implements your interface:

💡 Tip: Click dropdown to switch between languages

Python

Python

notifications.py

# Your own interface
class Notification:
    def send(self, message: str):
        pass

# Adapter that wraps the third-party class
class ThirdPartyEmailAdapter(Notification):
    def __init__(self, email_service: ThirdPartyEmailService, recipient: str):
        self.email_service = email_service  # Composition
        self.recipient = recipient

    def send(self, message: str):
        # Adapt the third-party interface to your interface
        self.email_service.send_email(
            to=self.recipient,
            subject="Notification",
            body=message
        )

# Usage
email_service = ThirdPartyEmailService()
notification = ThirdPartyEmailAdapter(email_service, "[email protected]")
notification.send("Build completed!")

Java

ThirdPartyEmailAdapter.java

// Your own interface
public abstract class Notification {
    public abstract void send(String message);
}

// Adapter that wraps the third-party class
public class ThirdPartyEmailAdapter extends Notification {
    private ThirdPartyEmailService emailService; // Composition
    private String recipient;

    public ThirdPartyEmailAdapter(ThirdPartyEmailService emailService, String recipient) {
        this.emailService = emailService;
        this.recipient = recipient;
    }

    @Override
    public void send(String message) {
        // Adapt the third-party interface to your interface
        emailService.sendEmail(recipient, "Notification", message);
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        ThirdPartyEmailService emailService = new ThirdPartyEmailService();
        Notification notification = new ThirdPartyEmailAdapter(emailService, "[email protected]");
        notification.send("Build completed!");
    }
}

TypeScript

notifications.ts

// Your own interface
abstract class Notification {
    abstract send(message: string): void;
}

// Adapter that wraps the third-party class
class ThirdPartyEmailAdapter extends Notification {
    constructor(
        private emailService: ThirdPartyEmailService,  // Composition
        private recipient: string
    ) {
        super();
    }

    send(message: string): void {
        // Adapt the third-party interface to your interface
        this.emailService.sendEmail(this.recipient, "Notification", message);
    }
}

// Usage
const emailService = new ThirdPartyEmailService();
const notification = new ThirdPartyEmailAdapter(emailService, "[email protected]");
notification.send("Build completed!");

C++

ThirdPartyEmailAdapter.cpp

#include <string>
#include <iostream>
#include <memory>

// Your own interface
class Notification {
public:
    virtual ~Notification() = default;
    virtual void send(const std::string& message) = 0;
};

// Adapter that wraps the third-party class
class ThirdPartyEmailAdapter : public Notification {
private:
    std::shared_ptr<ThirdPartyEmailService> emailService;  // Composition
    std::string recipient;

public:
    ThirdPartyEmailAdapter(std::shared_ptr<ThirdPartyEmailService> emailService,
                          const std::string& recipient)
        : emailService(emailService), recipient(recipient) {}

    void send(const std::string& message) override {
        // Adapt the third-party interface to your interface
        emailService->sendEmail(recipient, "Notification", message);
    }
};

// Usage
int main() {
    auto emailService = std::make_shared<ThirdPartyEmailService>();
    auto notification = std::make_shared<ThirdPartyEmailAdapter>(
        emailService, "[email protected]");
    notification->send("Build completed!");
    return 0;
}

C#

ThirdPartyEmailAdapter.cs

using System;

// Your own interface
public abstract class Notification
{
    public abstract void Send(string message);
}

// Adapter that wraps the third-party class
public class ThirdPartyEmailAdapter : Notification
{
    private ThirdPartyEmailService emailService;  // Composition
    private string recipient;

    public ThirdPartyEmailAdapter(ThirdPartyEmailService emailService, string recipient)
    {
        this.emailService = emailService;
        this.recipient = recipient;
    }

    public override void Send(string message)
    {
        // Adapt the third-party interface to your interface
        emailService.SendEmail(recipient, "Notification", message);
    }
}

// Usage
class Program
{
    static void Main()
    {
        ThirdPartyEmailService emailService = new ThirdPartyEmailService();
        Notification notification = new ThirdPartyEmailAdapter(emailService, "[email protected]");
        notification.Send("Build completed!");
    }
}

Go

third_party_email_adapter.go

package main

import "fmt"

// Your own interface
type Notification interface {
  Send(message string)
}

// Adapter that wraps the third-party struct
type ThirdPartyEmailAdapter struct {
  emailService *ThirdPartyEmailService
  recipient    string
}

func NewThirdPartyEmailAdapter(svc *ThirdPartyEmailService, recipient string) *ThirdPartyEmailAdapter {
  return &ThirdPartyEmailAdapter{emailService: svc, recipient: recipient}
}

func (a *ThirdPartyEmailAdapter) Send(message string) {
  // Adapt the third-party interface to your interface
  a.emailService.SendEmail(a.recipient, "Notification", message)
}

func main() {
  emailService := &ThirdPartyEmailService{}
  notification := NewThirdPartyEmailAdapter(emailService, "[email protected]")
  notification.Send("Build completed!")
}

type ThirdPartyEmailService struct{}

func (s *ThirdPartyEmailService) SendEmail(to, subject, body string) {
  fmt.Printf("Third-party service sending email to %s\n", to)
}

Rust

third_party_email_adapter.rs

trait Notification {
    fn send(&self, message: &str);
}
struct ThirdPartyEmailService;
impl ThirdPartyEmailService {
    fn send_email(&self, to: &str, subject: &str, body: &str) {
        println!("Third-party email to {to}: {subject} - {body}");
    }
}
struct ThirdPartyEmailAdapter {
    service: ThirdPartyEmailService,
    to: String,
}
impl Notification for ThirdPartyEmailAdapter {
    fn send(&self, message: &str) {
        self.service.send_email(&self.to, "Notification", message);
    }
}

This way, you extend functionality (add new notification types) without modifying the third-party code, following OCP through composition.

2. Cross-Cutting Concerns

When you need to add functionality that doesn’t belong to the same domain (like logging, caching, or security), consider using decorators or aspect-oriented programming instead of modifying the base class.

Example: Adding audit logging without modifying the base class:

💡 Tip: Click dropdown to switch between languages

Python

Python

notifications.py

class Notification:
    def send(self, message: str):
        """Base method - closed for modification"""
        pass

class AuditLogger:
    """Decorator for cross-cutting concern"""
    def __init__(self, notification: Notification):
        self.notification = notification

    def send(self, message: str):
        print(f"[AUDIT] Sending notification: {message}")
        self.notification.send(message)

# Usage
email_notification = EmailNotification("[email protected]")
audited_notification = AuditLogger(email_notification)
audited_notification.send("Build completed!")

Java

AuditLogger.java

public abstract class Notification {
    public abstract void send(String message);
}

// Decorator for cross-cutting concern
public class AuditLogger extends Notification {
    private Notification notification;

    public AuditLogger(Notification notification) {
        this.notification = notification;
    }

    @Override
    public void send(String message) {
        System.out.println("[AUDIT] Sending notification: " + message);
        notification.send(message);
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Notification emailNotification = new EmailNotification("[email protected]");
        Notification auditedNotification = new AuditLogger(emailNotification);
        auditedNotification.send("Build completed!");
    }
}

TypeScript

notifications.ts

abstract class Notification {
    abstract send(message: string): void;
}

// Decorator for cross-cutting concern
class AuditLogger extends Notification {
    constructor(private notification: Notification) {
        super();
    }

    send(message: string): void {
        console.log(`[AUDIT] Sending notification: ${message}`);
        this.notification.send(message);
    }
}

// Usage
const emailNotification = new EmailNotification("[email protected]");
const auditedNotification = new AuditLogger(emailNotification);
auditedNotification.send("Build completed!");

C++

AuditLogger.cpp

#include <string>
#include <iostream>
#include <memory>

class Notification {
public:
    virtual ~Notification() = default;
    virtual void send(const std::string& message) = 0;
};

// Decorator for cross-cutting concern
class AuditLogger : public Notification {
private:
    std::shared_ptr<Notification> notification;

public:
    AuditLogger(std::shared_ptr<Notification> notification)
        : notification(notification) {}

    void send(const std::string& message) override {
        std::cout << "[AUDIT] Sending notification: " << message << std::endl;
        notification->send(message);
    }
};

// Usage
int main() {
    auto emailNotification = std::make_shared<EmailNotification>("[email protected]");
    auto auditedNotification = std::make_shared<AuditLogger>(emailNotification);
    auditedNotification->send("Build completed!");
    return 0;
}

C#

AuditLogger.cs

using System;

public abstract class Notification
{
    public abstract void Send(string message);
}

// Decorator for cross-cutting concern
public class AuditLogger : Notification
{
    private Notification notification;

    public AuditLogger(Notification notification)
    {
        this.notification = notification;
    }

    public override void Send(string message)
    {
        Console.WriteLine($"[AUDIT] Sending notification: {message}");
        notification.Send(message);
    }
}

// Usage
class Program
{
    static void Main()
    {
        Notification emailNotification = new EmailNotification("[email protected]");
        Notification auditedNotification = new AuditLogger(emailNotification);
        auditedNotification.Send("Build completed!");
    }
}

Go

audit_logger.go

package main

import "fmt"

// Decorator for cross-cutting concern
type AuditLogger struct {
  notification Notification
}

func NewAuditLogger(n Notification) *AuditLogger {
  return &AuditLogger{notification: n}
}

func (a *AuditLogger) Send(message string) {
  fmt.Printf("[AUDIT] Sending notification: %s\n", message)
  a.notification.Send(message)
}

func main() {
  emailNotification := NewEmailNotification("[email protected]")
  auditedNotification := NewAuditLogger(emailNotification)
  auditedNotification.Send("Build completed!")
}

Rust

audit_logger.rs

trait Notification {
    fn send(&self, message: &str);
}
struct AuditLogger<T: Notification> {
    inner: T,
}
impl<T: Notification> Notification for AuditLogger<T> {
    fn send(&self, message: &str) {
        println!("Audit: sending notification");
        self.inner.send(message);
    }
}
// Wrap behavior instead of modifying the core notifier.

3. Fundamental Behavior Changes

If the core behavior needs to change (not just extend), modification might be necessary. However, consider if this indicates a design issue that should be refactored. Sometimes, it’s better to create a new abstraction rather than modifying the existing one.

Key Takeaways

Remember

• OCP is a guideline, not an absolute rule - Use your judgment
• Prefer extension over modification - But know when modification is acceptable
• Use inheritance, interfaces, and composition - To achieve extensibility
• Consider adapters for third-party code - When you can’t modify external classes
• Isolate changes - Keep modifications localized and well-tested