Skip to main content

Open-Closed Principle – Simple Explanation with Example

When building applications, we often need to add new features or change behavior. A common mistake is modifying existing code every time we need something new.

This can easily introduce bugs and break parts of the system that were already working.

The Open-Closed Principle (OCP) helps solve this problem.

Single Responsibility Principle

What is Open-Closed Principle?

The idea is simple:

Software entities should be open for extension, but closed for modification.

That means:

  • You should be able to add new behavior
  • Without changing existing code

Why This Matters

When we modify existing code:

  • We risk breaking existing functionality
  • Testing becomes harder
  • The code becomes less stable over time

Instead, we should extend the code in a safe way.

Bad Example (Modifying Existing Code)

Let’s say we have a class that calculates discounts:


class DiscountService {
    calculate(price, type) {
        if (type === "regular") {
            return price * 0.1;
        } else if (type === "premium") {
            return price * 0.2;
        }
    }
}

Problem here:

  • Every time we add a new discount type, we must modify this class
  • This can break existing logic

Good Example (Open for Extension)

Instead of modifying the class, we can extend behavior:


// Base class
class Discount {
    calculate(price) {
        return 0;
    }
}

// Extended classes
class RegularDiscount extends Discount {
    calculate(price) {
        return price * 0.1;
    }
}

class PremiumDiscount extends Discount {
    calculate(price) {
        return price * 0.2;
    }
}

Now we use them like this:


function getDiscount(discount, price) {
    return discount.calculate(price);
}

Why this is better:

  • We don’t change existing code
  • We add new behavior using new classes
  • The system becomes more stable and flexible

Adding a new discount is easy:


class FestivalDiscount extends Discount {
    calculate(price) {
        return price * 0.3;
    }
}

No need to modify old code.

Going One Step Further (Better Design)

In real-world applications, we often combine OCP with dependency injection.


class CheckoutService {
    constructor(discount) {
        this.discount = discount;
    }

    getFinalPrice(price) {
        return price - this.discount.calculate(price);
    }
}

Now we can pass any discount type:


const discount = new PremiumDiscount();
const checkout = new CheckoutService(discount);

console.log(checkout.getFinalPrice(100));

This makes the system flexible and easy to extend.

Real-Life Analogy

Think of a mobile phone:

  • You don’t modify the phone to add new features
  • You install apps to extend functionality

The phone is closed for modification but open for extension.

Key Idea to Remember

  • Don’t modify existing working code
  • Extend behavior using new classes
  • Keep your system stable

Conclusion

At first, modifying existing code may seem easier. But as your project grows, it increases risk and complexity.

By following the Open-Closed Principle, your code becomes:

  • Easier to extend
  • Safer to maintain
  • More scalable


Comments

Post a Comment

Popular posts from this blog

SOLID Principles – Simple Explanation for Beginners

 When I started learning object-oriented programming, I often wrote code that worked—but was hard to maintain or extend later. That’s when I came across the SOLID principles. These are five simple guidelines that help us write code that is: Easy to understand Easy to maintain Easy to scale In this blog, I’ll explain each principle in a simple way so you can understand the idea clearly. What are SOLID Principles? SOLID is a set of five design principles introduced by Robert C. Martin. Each letter represents one principle: S → Single Responsibility O → Open-Closed L → Liskov Substitution I → Interface Segregation D → Dependency Inversion S — Single Responsibility Principle (SRP) A class should have only one responsibility. Simple idea A class should do only one job. If a class has multiple responsibilities: It becomes harder to manage Changes in one part can affect other parts Example thinking Instead of: One class handling user data + logging + validation Split it into: One class fo...
Post a Comment
Read more

Single Responsibility Principle – Simple Explanation with Example

When writing code, it’s common to put multiple responsibilities inside a single file or class. It might work at first, but over time it becomes difficult to manage and update. The Single Responsibility Principle (SRP) helps solve this. It is one of the core ideas from SOLID and focuses on keeping code simple and maintainable. What is Single Responsibility Principle? The idea is simple: A class should have only one responsibility. That means: It should do one job It should have only one reason to change Why This Matters When a class does too many things: Changes become risky Bugs become harder to track Code becomes difficult to understand Keeping responsibilities separate makes your code: Cleaner Easier to maintain Easier to scale Bad Example (Multiple Responsibilities in One Class) Let’s look at a class that handles everything: class UserService { validateUser(user) { if (!user.email) { console.log...
Post a Comment
Read more

Oops Concepts : Inheritance In Java

When I first started learning Java, inheritance felt a bit confusing. But once I understood the basic idea, it became one of the easiest and most powerful concepts in Object-Oriented Programming (OOP). In this blog, I’ll explain inheritance in very simple English, so even if you're a beginner student or aspiring developer, you can understand it easily.  What is Inheritance in Java? In simple words, inheritance means reusing code from another class. I usually think of it like this: A child inherits features from parents Similarly, a class can inherit properties and methods from another class Definition: Inheritance is a mechanism where a child class gets properties and methods from a parent class. Key Terms (Very Important) Parent Class (Superclass) → The class that provides properties Child Class (Subclass) → The class that inherits those properties How Inheritance Works in Java Java uses the keyword:           extends Basic Syntax: This means the Chil...
Post a Comment
Read more