Software Design - Introduction to SOLID Principles || SOLID Principles || SOLID Design Principles
Software Design - Introduction to SOLID Principles || SOLID Principles || SOLID Design Principles
In this video, we're going to explore SOLID principle with real-life Examples.
First we need to know what is SOLID principle ?
The SOLID principle helps in reducing tight coupling.
Tight coupling means a group of classes are highly dependent on one another which you should avoid in your code.
Loosely coupled classes minimize changes in your code, helps in making code more reusable, maintainable, flexible and stable.
The five SOLID principles are as follows:
------------------------------------------------------------------------------------------------------------------------------------------
1.Single Responsibility Principle (SRP):
This principle states that “a class should have only one reason to change”
which means every class should have a single responsibility or single job or single purpose.
Example : Most of the time it happens that when programmers have to add features or new behavior they implement everything into the existing class which is completely wrong. Use layers in your application and break God classes into smaller classes or modules.
------------------------------------------------------------------------------------------------------------------------------------------
2.Open/Closed Principle (OCP):
This principle states that “software entities (classes, modules, functions, etc.)
should be open for extension, but closed for modification”.
Example : Using this principle separates the existing code from the modified code so it provides better stability,
maintainability and minimizes changes as in your code.
------------------------------------------------------------------------------------------------------------------------------------------
3.Liskov Substitution Principle (LSP):
According to this principle “Derived or child classes must be substitutable for their base or parent classes“. This principle ensures that any class that is the child of a parent class should be usable in place of its parent without any unexpected behavior.
Example: farmer’s son
You can understand it in a way that a farmer’s son should inherit farming skills from his father and should be able to replace his father if needed. If the son wants to become a farmer then he can replace his father but if he wants to become a cricketer then definitely the son can’t replace his father even though they both belong to the same family hierarchy.
------------------------------------------------------------------------------------------------------------------------------------------
4. Interface Segregation Principle (ISP):
This principle is the first principle that applies to Interfaces instead of classes in SOLID.
it is similar to the single responsibility principle. You should prefer many client interfaces rather than one general interface and each interface should have a specific responsibility.
Example : restaurant menu card
Suppose if you enter a restaurant and you are pure vegetarian. The waiter in that restaurant gave you the menu card which includes vegetarian items, non-vegetarian items, drinks, and sweets. In this case, as a customer, you should have a menu card which includes only vegetarian items, not everything which you don’t eat in your food. Here the menu should be different for different types of customers. The common or general menu card for everyone can be divided into multiple cards instead of just one.
------------------------------------------------------------------------------------------------------------------------------------------
5. Dependency Inversion Principle (DIP):
High-level modules/classes should not depend on low-level modules/classes. Both should depend upon abstractions.
Example : TV remote battery
You can consider the real-life example of a TV remote battery. Your remote needs a battery but it’s not dependent on the battery brand. You can use any XYZ brand that you want and it will work. So we can say that the TV remote is loosely coupled with the brand name. Dependency Inversion makes your code more reusable.
"Remember, applying SOLID principles in your software design can lead to more flexible, scalable, and maintainable code.
I hope this video has helped you to better understand the importance of these principles and how they can be applied in your own projects.