SOLID Principals - Open-Closed Principle (OCP)
The Open-Closed Principle (OCP) is one of the SOLID principles that emphasizes the idea that classes should be open for extension but closed for modification. This principle encourages developers to design software entities in a way that allows for new functionality to be added without altering existing code.
Understanding the Open-Closed Principle
The Open-Closed Principle states that a class should be open for extension but closed for modification. This means that you should be able to extend the behavior of a class without changing its source code. The goal is to promote software entities that are easily extensible without introducing potential bugs or unintended side effects.
Example 1: Basic Implementation
Let’s consider a simple example where we have a class representing different shapes, and we want to calculate the area of each shape. Initially, we may have a class like this:
class Rectangle
attr_accessor :width, :height
def initialize(width, height)
@width = width
@height = height
end
def area
width * height
end
end
In this example, if we later want to add support for calculating the area of a circle, we might be tempted to modify the existing Rectangle class. However, this violates the Open-Closed Principle.
Refactoring for Open-Closed Principle
To adhere to the Open-Closed Principle, we can introduce an abstract base class (Shape) and create specific implementations for each shape:
class Shape
# Common methods or properties for all shapes can go here
end
class Rectangle < Shape
attr_accessor :width, :height
def initialize(width, height)
@width = width
@height = height
end
def area
width * height
end
end
class Circle < Shape
attr_accessor :radius
def initialize(radius)
@radius = radius
end
def area
Math::PI * radius**2
end
end
Now, we can extend our system by adding new shapes without modifying the existing code. Each new shape is a class that inherits from the common Shape class and provides its own implementation of the area method.
Example 2: Strategy Pattern
The Open-Closed Principle can also be applied using design patterns. Let’s consider the Strategy Pattern, which allows us to define a family of algorithms, encapsulate each one, and make them interchangeable.
class Order
attr_accessor :total, :discount_strategy
def initialize(total, discount_strategy)
@total = total
@discount_strategy = discount_strategy
end
def final_total
total - discount_strategy.apply_discount(total)
end
end
class ChristmasDiscount
def apply_discount(total)
total * 0.1 # 10% discount for Christmas
end
end
class BlackFridayDiscount
def apply_discount(total)
total * 0.2 # 20% discount for Black Friday
end
end
In this example, the Order class is open for extension because we can add new discount strategies without modifying the existing code. Each discount strategy is encapsulated in its own class, adhering to the Open-Closed Principle.
The Open-Closed Principle encourages a design philosophy that facilitates extending software entities without modifying their existing code. By using abstraction, inheritance, and design patterns, developers can create systems that are more flexible, maintainable, and scalable.