0% completed
Single Responsibility Principle (SRP)
The Single Responsibility Principle states that:
Every software component should have only one and one job or responsibility.
In simpler terms, a software component should focus on doing one thing and doing it well. It should only have one responsibility or task.
General Example: Army Knife vs. Simple Knife
Before we dive deeper into the principle, let’s think about a general example: an army knife vs. a simple knife.
-
Army Knife: An army knife has multiple tools like scissors, bottle openers, screwdrivers, and more. While it can do a lot of tasks, it’s not the best at any single one of them.
-
Simple Knife: On the other hand, a simple kitchen knife has one job: to cut. It’s sharp, efficient, and perfect for slicing food. It doesn’t try to do everything.
As shown in the image, the army knife has many tools that violate the single responsibility principle, while the simple knife is built for one purpose and follows the single responsibility principle.
Explaining the Principle
In software development, this principle doesn’t just apply to classes. It also applies to methods, modules, and other components of your system. Each part should have a single, well-defined job. If a class is responsible for multiple things, it will become harder to maintain and understand.
For example:
- A class should be responsible for one specific task.
- A method should perform one specific action.
- A module should handle one specific area of functionality.
By following this principle, you ensure that your code is easier to understand and maintain. If you ever need to make changes, you’ll know exactly where to make them without affecting unrelated parts of the code.
Table of Contents
Single Responsibility Principle (SRP)
General Example: Army Knife vs. Simple Knife
Explaining the Principle