Design Pattern Series - Single Responsibility Principle

shivasubramaniamR — Thu, 15 Jun 2023 11:05:31 +0000

Before we Move on to Design Patterns, It is vital to see the SOLID Principles, the First Acronym S - > Single Responsibility principle. Let's dive into the What, Why and How

What is SRP?
The Single Responsibility Principle (SRP) is a fundamental principle in software development and object-oriented design. It states that a class or module should have only one reason to change, meaning it should have a single responsibility.

Why SRP is needed?
SRP is needed for the below reasons

Code maintainability
Code reusability
Easy Testability
Flexibility and extensibility
Reduced coupling

How SRP is implemented?
For this implementation, we will use Java as the programming Language

we will have three classes

one without SRP
SRP implemented
how functionality separated

public class WithoutSingleResponsibility {

    private String book;
    private String author;

    public String getAuthor() {
        return author;
    }
    public void setAuthor(String author) {
        this.author = author;
    }
    public String getBook() {
        return book;
    }
    public void setBook(String book) {
        this.book = book;
    }
    public void searchBook() {

    }
}

Explanation:
In the Above class, we have the getters and setters for the author and Book, and the intention of the class is to deal with the book and author. But the problem arises with the search book method. It leads to problems when the author name and book are set. So search method is not part of this class, and it needs to be separated from this class.

public class WithSingleResponsibility {

    private String book;
    private String author;

    public String getAuthor() {
        return author;
    }
    public void setAuthor(String author) {
        this.author = author;
    }
    public String getBook() {
        return book;
    }
    public void setBook(String book) {
        this.book = book;
    }

}

Explanation:
Now that we have removed the search book from this class, this is a classical example of SRP.

public class WithSingleResponsibilitySearchSeperated {

    WithSingleResponsibility withSingleResponsibility;

public WithSingleResponsibilitySearchSeperated(WithSingleResponsibility withSingleResponsibility) {
this.withSingleResponsibility = withSingleResponsibility;

}

public void searchBook() {
    withSingleResponsibility.getBook();
    withSingleResponsibility.getAuthor();
}

}

Explanation
This is the Separated class, where we create an object of the SRP class and will use it according to the functionality

Design Pattern Series - SOLID

shivasubramaniamR — Wed, 14 Jun 2023 12:10:22 +0000

First things first, why do we need Design Pattern ?

we can get many answers for the above question, but the crux of Design pattern is as below

Design Patterns provide easy to recognize and use OOP solutions to common problems that arise in software development and provide proven solutions.

Before we dive into the Design Patterns, it is important to learn about the SOLID Principles.

SOLID is an acronym that represents a set of five design principles in object-oriented programming (OOP) that aim to make software designs more maintainable, flexible, and robust. The SOLID principles were introduced by Robert C. Martin (also known as Uncle Bob) and have become widely adopted in the software development industry

S -> Single Responsibility Principle (SRP)
O -> Open/Closed Principle (OCP)
L -> Liskov Substitution Principle (LSP)
I -> Interface Segregation Principle (ISP)
D -> Dependency Inversion Principle (DIP)

These SOLID principles work together to create a codebase that is more maintainable, extensible, and easier to understand.

Now the Million Dollar Question - Who should use this? is it Only a developer? Automation Testers(QA) don't need it ?

Ofcourse it is needed by QA(Automation testers). When the Code base grows bigger, without these SOLID Principles and Design Pattern, It is very tedious to maintain that code base.

DEV Community: shivasubramaniamR

Design Pattern Series - Single Responsibility Principle

Design Pattern Series - SOLID