This document discusses the single responsibility principle (SRP) in software design. It provides examples of classes that violate SRP by having multiple responsibilities, and refactors them to have single responsibilities by separating concerns into distinct classes. The SRP states that every class should have one single responsibility, meaning there should be only one reason for a class to change. Well-designed classes focus on doing one thing well without overlapping functionality or dependencies between concepts.

1. Introducing
Single Responsibilty Pattern

2. OOP in the real world

4. OOP Principles

5. Abstraction
●
abstraction is the art of hiding implementation
details from the user and provide the user with
what they want.
●
It can be using interfaces or abstract class

6. https://javatutorial.net/java-abstraction-example

7. https://github.com/shiddiqeuy/Java-Abstraction

8. Encapsulation
●
The localization of knowledge within a module.
Because objects encapsulate data and
implementation, the user of an object can view the
object as a black box that provides services. Instance
variables and methods can be added, deleted, or
changed, but as long as the services provided by the
object remain the same, code that uses the object can
continue to use it without being rewritten.
https://docs.oracle.com/javase/tutorial/information/glossary.html#encapsulation

9. https://javatutorial.net/java-encapsulation-example

10. ●
Inheritance
●
Polymorphism

11. The Common Problems

12. Spagheti Code

13. Loose vs Thight Coupled

14. Tighly Coupled
●
Tight coupling is when a group of classes are
highly dependent on one another.
●
See more on
https://intesar1994.weebly.com/types-of-
coupling-in-java.html

15. SOLID Principle

16. Robert C Martin a.k.a Uncle Bob

17. S.O.L.I.D
●
Single responsibility
●
Open closed principle
●
Liskov subtitution
●
Interface segregation
●
Dependency inversion

18. Single Responsibility
●
each class (microservice, code module,
function, method) should have only one single
responsibility.
●
Responsibility is used in the sense of having
only one reason to change.

19. Class User{
String name;
Int age;
public boolean isAgeAllowed(){
return age > 17;
}
}
Class User{
String name;
Int age;
}
Class UserValidation{
private User user;
public UserValidation(User _user){
this.user = _user;
}
public boolean isAgeAllowed(){
return this.age > 17;
}
}
good
better

20. class User
{
void CreatePost(Database db, string postMessage)
{
try
{
db.Add(postMessage);
}
catch (Exception ex)
{
db.LogError("An error occured: ", ex.ToString());
File.WriteAllText("LocalErrors.txt", ex.ToString());
}
}
}
Good
https://itnext.io/solid-principles-explanation-and-examples-715b975dcad4

21. class Post
{
private ErrorLogger errorLogger = new ErrorLogger();
void CreatePost(Database db, string postMessage)
{
try
{
db.Add(postMessage);
}
catch (Exception ex)
{
errorLogger.log(ex.ToString())
}
}
}
class ErrorLogger
{
void log(string error)
{
db.LogError("An error occured: ", error);
File.WriteAllText("LocalErrors.txt", error);
}
}
Better

22. <?php
class Car
{
public function speed()
{
return 'go fast';
}
public function steer()
{
return 'turn left';
}
}
$car = new Car;
$car->speed(); // go fast
$car->steer(); // turn left

23. class Accelerator
{
public function go()
{
return 'going fast';
}
}
$car = new Car(new Accelerator, new
Steering);
$car->speed(); // going fast
$car->steer(); // turn left
class Car
{
protected $speed;
lic function __construct(Accelerator $speed, Steering $steer)
{
$this->speed = $speed;
$this->steer = $steer;
}
public function speed()
{
echo $this->speed->go();
}
public function steer()
{
echo $this->steer->turn();
}
}
class Steering
{
public function turn()
{
return 'turn left';
}
}