Open/Closed Principle – Damian Kaczmarzyk

The Open/Closed Principle (OCP) is one of the five SOLID principles of object-oriented programming (OOP) that guide the design of software to be more flexible and maintainable. OCP was introduced by Bertrand Meyer, and it states that:

“Software entities (classes, modules, functions, etc.) should be open for extension but closed for modification.”

In other words, you should be able to add new functionality to an existing class or module without modifying its existing code. This encourages building systems that are resilient to change and can be extended without altering their core functionality.

Why Is the Open/Closed Principle Important?

Maintainability: As systems grow, constantly modifying existing code can introduce bugs. OCP helps prevent this by encouraging extension over modification.
Flexibility: When a new requirement emerges, developers can extend the behavior of classes without touching the stable, tested code.
Testability: Following OCP can lead to systems that are easier to test, as you isolate new behavior in separate components.

Violating the Open/Closed Principle

Let’s start with an example that violates the Open/Closed Principle. Imagine we have a simple class that calculates the area of different shapes:

class AreaCalculator: 
    def calculate_area(self, shape): 
        if isinstance(shape, Rectangle): 
            return shape.width * shape.height 
        elif isinstance(shape, Circle): 
            return 3.14 * shape.radius ** 2

class AreaCalculator:

def calculate_area(self, shape):

if isinstance(shape, Rectangle):

return shape.width * shape.height

elif isinstance(shape, Circle):

return 3.14 * shape.radius ** 2

Here, the AreaCalculator class depends on the specific types of shapes. If we later need to add more shapes, like a Triangle or a Square, we would have to modify this class by adding more elif conditions. This violates OCP because we’re altering the existing class instead of extending it.

Applying the Open/Closed Principle

To follow the Open/Closed Principle, we can refactor the code by introducing polymorphism. This allows us to add new shapes without modifying the AreaCalculator class.

Here’s how we can refactor the code:

from abc import ABC, abstractmethod

# Step 1: Create a base Shape class
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

# Step 2: Implement different shapes by extending the base class
class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

# Step 3: Refactor AreaCalculator to work with the Shape interface
class AreaCalculator:
    def calculate_area(self, shape: Shape):
        return shape.area()

# Step 4: Adding new shapes without modifying the AreaCalculator
class Triangle(Shape):
    def __init__(self, base, height):
        self.base = base
        self.height = height

    def area(self):
        return 0.5 * self.base * self.height

from abc import ABC, abstractmethod

# Step 1: Create a base Shape class

class Shape(ABC):

@abstractmethod

def area(self):

pass

# Step 2: Implement different shapes by extending the base class

class Rectangle(Shape):

def __init__(self, width, height):

self.width = width

self.height = height

def area(self):

return self.width * self.height

class Circle(Shape):

def __init__(self, radius):

self.radius = radius

def area(self):

return 3.14 * self.radius ** 2

# Step 3: Refactor AreaCalculator to work with the Shape interface

class AreaCalculator:

def calculate_area(self, shape: Shape):

return shape.area()

# Step 4: Adding new shapes without modifying the AreaCalculator

class Triangle(Shape):

def __init__(self, base, height):

self.base = base

self.height = height

def area(self):

return 0.5 * self.base * self.height

How This Follows the Open/Closed Principle

Open for Extension: We can now add new shapes (e.g., Triangle, Square) by simply creating new classes that inherit from Shape and implement the area() method. No modification to the AreaCalculator class is required.
Closed for Modification: The AreaCalculator class no longer needs to be changed when new shapes are introduced. Instead, it works with any shape that implements the area() method, thus adhering to OCP.

Benefits of this Approach

Extensibility: You can add as many shapes as you like, without worrying about modifying existing code.
Adherence to OCP: The core logic of AreaCalculator remains untouched, ensuring stability.
Flexibility: This design is flexible because the system grows by adding new classes rather than changing existing ones.

Conclusion

The Open/Closed Principle promotes a design that can evolve over time through extension, not modification. By adhering to OCP, we reduce the chances of introducing bugs when adding new features. In Python, we can apply OCP by using inheritance and abstract methods, allowing new functionality to be added while keeping the core logic intact. This leads to a more maintainable and flexible codebase in the long run.