Apr 12, 2023

14 min read

SOLID: The First 5 Principles of Object Oriented Design

Written by

Abdelhadi Dyouri

The SOLID Principles of Object Oriented Design


The SOLID Principles of Object Oriented Design are a set of guidelines that help developers create software that is easy to maintain and extend. These principles were created by Robert C. Martin in the early 2000s and are based on the principles of object-oriented programming. The acronym SOLID stands for: Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. These principles help developers create code that is easy to read, maintain, and extend. By following these principles, developers can create software that is more reliable, efficient, and maintainable.

Single Responsibility Principle

The Single Responsibility Principle (SRP) is a core principle of object-oriented design and software development. It states that every class should have a single responsibility, and that responsibility should be entirely encapsulated by the class. This means that a class should only have one reason to change, and that any changes to the class should only affect its primary responsibility. The SRP helps to reduce complexity and increase maintainability by ensuring that classes are focused and cohesive. It also helps to ensure that changes to a class do not have unintended consequences on other parts of the system.

Example of the Single Responsibility Principle in Python

class User:
    def __init__(self, name): = name

class UserManager:
    def __init__(self):
        self.users = []

    def add_user(self, user):

The code above demonstrates the Single Responsibility Principle in the SOLID principles. The User class is responsible for storing the name of the user, while the UserManager class is responsible for managing the list of users. This separation of responsibilities allows for better code maintainability and scalability.

Open/closed Principle

The Open/closed principle states that software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification. This means that the behavior of the software should be able to be extended without having to modify existing code. This allows for code reuse and flexibility, and helps to reduce the amount of time and effort needed to make changes to the software. This principle encourages the use of abstraction and encapsulation, which are key concepts in object-oriented programming. By adhering to this principle, developers can create software that is more maintainable and extensible.


The following example demonstrates the Open/Closed Principle by creating an abstract class, Shape, and two subclasses, Circle and Rectangle, that extend the Shape class:

class Shape:
    def area(self):

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

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

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

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

In this example, the Shape class is open for extension, as we can create subclasses that extend it. However, the Shape class is closed for modification, as we cannot directly modify the class. We can only extend it by creating subclasses. With this, you can have a different area() method for each class.

Liskov Substitution Principle

The Liskov Substitution Principle states that, in a computer program, if S is a subtype of T, then objects of

Continue reading this article
by subscribing to our newsletter.
Subscribe now

Leave a Reply