What Is Solid Principle ?
While developing any software Object-Oriented Design plays a crucial role when it comes to writing flexible, scalable, maintainable, and reusable code.
There are so many benefits of using OOD but every developer should also have the knowledge of the SOLID principle for good object-oriented design in programming.
The SOLID principle was introduced by Robert C. Martin, also known as Uncle Bob and it is a coding standard in programming.
The SOLID principles in Python are mentioned below
1. Single Responsibility Principle (SRP):
• A class should always have a single reason to change.
• Each class should have a single responsibility or purpose.
• This helps in achieving high cohesion and reduces coupling between classes.
2. Open/Closed Principle (OCP):
• Software entities like classes, modules, functionsshould be open for extension but they should be closed for modification.
• It supports the use of abstraction and interfaces to allow adding new functionalities without modifying the existing code.
• Code can be reused and the risk of introducing bugs in existing code is reduced.
3. Liskov Substitution Principle (LSP):
• According to this principle, The objects of a superclass should be replaceable with objects of its subclasses which should not break the original program.
• Derived classes should be able to be used in place of their base classes without causing any unexpected behavior or violating the expected contracts.
• Ensures that polymorphism is correctly implemented and helps maintain the behavior and consistency of the code.
4. Interface Segregation Principle (ISP):
• Clients should not be forced to depend on interfaces they do not use.
• It encourages the creation of smaller, more specific interfaces rather than large, general-purpose ones.
• Avoids the situation where classes are forced to implement methods they don’t need, promoting code decoupling and flexibility.
5. Dependency Inversion Principle (DIP):
• High-level modules should not depend on low-level modules. Both should depend on abstractions.
• Abstractions should not depend on details; details should depend on abstractions.
• Encourages the use of dependency injection and inversion of control to reduce direct dependencies between modules and promote modular and testable code.
Let’s consider an example python code which involves this SOLID principles in it :
First let us declare a class called book with the parameters title, author, and content.
Usage of Single Responsibility Principle:
In the below code snippet, the Book class is responsible for representing a book and storing its title, author, and content. Its main purpose is to encapsulate the data associated with a book and provide methods to access this data.
Adhering to OCP allows adding new printing or formatting functionalities without modifying the Book class, while following LSP ensures that subclasses like EBook can be used interchangeably with Book objects without unexpected behavior.
Usage of Open/Closed Principle (OCP) and Liskov Substitution Principle (LSP):
Adhering to OCP allows adding new printing or formatting functionalities without modifying the Book class, while following LSP ensures that subclasses like EBook can be used interchangeably with Book objects without unexpected behavior.
Usage of Interface Segregation Principle (ISP):
By separating the printing functionality into a separate interface (PrintableBook), It allows clients to depend on specific interfaces they require, which promotes flexibility and avoids unnecessary dependencies.
Usage of dependency Inversion Principle (DIP):
The BookPublisher class in the Book example adheres to the Dependency Inversion Principle (DIP) by depending on the PrintableBook interface instead of the concrete Book class, enabling flexibility, modularity, and decoupling between high-level and low-level modules.
Conclusion:
The SOLID principles provide guidelines for writing maintainable and flexible code. By applying these principles, we can achieve a modular, extensible, and easier form of code. Each principle focuses on a specific aspect, such as single responsibility, open for extension, substitutability, interface segregation, and dependency inversion, contributing to overall code quality and robustness.
Thank You
Pooja TS
Helical IT Solutions
Best Open Source Business Intelligence Software Helical Insight is Here
