Skip to main content

Single Responsibility Principle – Simple Explanation with Example

When writing code, it’s common to put multiple responsibilities inside a single file or function. It might work at first, but over time it becomes difficult to manage and update.

The Single Responsibility Principle (SRP) helps solve this.

It is one of the core ideas from SOLID and focuses on keeping code simple and maintainable.

SOLID Principles Thumbnail

What is Single Responsibility Principle?

The idea is simple:

A class or function should have only one responsibility.

That means:

  • It should do one job
  • It should have one reason to change

Why This Matters

When a class does too many things:

  • Changes become risky
  • Bugs become harder to track
  • Code becomes difficult to understand

Keeping responsibilities separate makes your code:

  • Cleaner
  • Easier to maintain
  • Easier to scale

Bad Example (Multiple Responsibilities)

Let’s say we have a function like this:


function processUserData(user) {
    // validate user
    if (!user.email) {
        console.log("Invalid user");
        return;
    }

    // save user
    console.log("Saving user to database");

    // send email
    console.log("Sending welcome email");
}

Problem here:

  • Validation
  • Saving data
  • Sending email

If something changes (like email logic), you must modify this function.

Good Example (Single Responsibility)

Now let’s split the responsibilities:


function validateUser(user) {
    return user.email ? true : false;
}

function saveUser(user) {
    console.log("Saving user to database");
}

function sendEmail(user) {
    console.log("Sending welcome email");
}

Now use them:


function processUser(user) {
    if (!validateUser(user)) return;

    saveUser(user);
    sendEmail(user);
}

Why this is better:

  • Each function does one job
  • Easy to update or replace any part
  • Code becomes reusable

Real-Life Analogy

Think of a restaurant:

  • Chef – cooks food
  • Cashier – handles billing
  • Delivery – delivers food

If one person does everything, it becomes messy.

Key Idea to Remember

  • Doing one thing
  • Doing it well
  • Keeping things separate

Conclusion

At the beginning, combining everything in one place might feel faster. But as your project grows, it creates problems.

By following SRP, your code becomes:

  • Easier to read
  • Easier to modify
  • More organized

Comments

Post a Comment

Popular posts from this blog

SOLID Principles – Simple Explanation for Beginners

 When I started learning object-oriented programming, I often wrote code that worked—but was hard to maintain or extend later. That’s when I came across the SOLID principles. These are five simple guidelines that help us write code that is: Easy to understand Easy to maintain Easy to scale In this blog, I’ll explain each principle in a simple way so you can understand the idea clearly. What are SOLID Principles? SOLID is a set of five design principles introduced by Robert C. Martin. Each letter represents one principle: S → Single Responsibility O → Open-Closed L → Liskov Substitution I → Interface Segregation D → Dependency Inversion S — Single Responsibility Principle (SRP) A class should have only one responsibility. Simple idea A class should do only one job. If a class has multiple responsibilities: It becomes harder to manage Changes in one part can affect other parts Example thinking Instead of: One class handling user data + logging + validation Split it into: One class fo...
Post a Comment
Read more

Oops Concepts : Inheritance In Java

When I first started learning Java, inheritance felt a bit confusing. But once I understood the basic idea, it became one of the easiest and most powerful concepts in Object-Oriented Programming (OOP). In this blog, I’ll explain inheritance in very simple English, so even if you're a beginner student or aspiring developer, you can understand it easily.  What is Inheritance in Java? In simple words, inheritance means reusing code from another class. I usually think of it like this: A child inherits features from parents Similarly, a class can inherit properties and methods from another class Definition: Inheritance is a mechanism where a child class gets properties and methods from a parent class. Key Terms (Very Important) Parent Class (Superclass) → The class that provides properties Child Class (Subclass) → The class that inherits those properties How Inheritance Works in Java Java uses the keyword:           extends Basic Syntax: This means the Chil...
Post a Comment
Read more