What is the open/closed principle in object-oriented…

The Open-Closed Principle (OCP) states that software entities (classes, modules, functions, etc.) should be open for extension but closed for modification.

This means that the behavior of a system can be changed and extended by adding new code, rather than modifying existing, tested code. This approach minimizes the risk of introducing errors into stable parts of the system.

Examples of implementing OCP:

Using abstractions (interfaces or abstract classes): Client code interacts with an abstraction, not with a specific implementation. New implementations can be added without changing the client code.

# Example without OCP
class ReportGenerator:
    def generate_pdf(self, data):
        # PDF generation logic
        pass

    def generate_csv(self, data):
        # CSV generation logic
        pass
# If you need to add XML generation, you'll have to modify this class.

# Example with OCP
from abc import ABC, abstractmethod

class ReportGenerator(ABC):
    @abstractmethod
    def generate(self, data):
        pass

class PdfReportGenerator(ReportGenerator):
    def generate(self, data):
        # PDF generation logic
        pass

class CsvReportGenerator(ReportGenerator):
    def generate(self, data):
        # CSV generation logic
        pass
# Now you can add XmlReportGenerator without changing existing classes.

Using inheritance: Extending functionality by creating subclasses that inherit behavior from a base class and add their own specific logic.
Strategy pattern: Defining a family of algorithms, encapsulating each one, and making them interchangeable. Client code uses the strategy through a common interface.

Advantages of adhering to OCP:

Increased stability: Less chance of breaking existing functionality when adding new features.
Improved maintainability: Code is easier to understand and modify, as changes are localized.
Easier testing: Modules are easier to test individually, as they are less dependent.
Greater flexibility: The system is easier to adapt to new requirements.

What is the open/closed principle in object-oriented programming?