Does the Single Responsibility Principle work in OOP?

by

I like to state the single responsibility principle this way: “Every thing you write — every module, class, interface, or method, should have one job. It should do the whole job and only that job.

Notice that some of these things you write are big (modules), some are small (methods), some are in between (classes), and some of the big things are made of smaller things.

That is not a problem, because jobs or responsibilities also come in various sizes and can be decomposed hierarchically. The job of the police force, for example, is to “protect and serve” — one job, that decomposes into “patrol the streets”, “solve crimes”, etc., which can each be handled by a different unit. That creates the need for coordination (a different job), and the job of each unit breaks down into jobs for individual officers, etc.

For every big job, there are many ways to break it down into smaller jobs, and every one of those can be modeled by a software design that adheres to SRP and the other SOLID principles. Deciding how to break a problem down is a big part of the art of software design.

More Related Contents:

  1. In SOLID, what is the distinction between SRP and ISP? (Single Responsibility Principle and Interface Segregation Principle)
  2. What is the scope of the Single Responsibility Principle? [closed]
  3. Interface Segregation Principle- Program to an interface
  4. What is an example of the Single Responsibility Principle? [closed]
  5. Can’t seem to understand SOLID principles and design patterns [closed]
  6. What is an example of the Liskov Substitution Principle?
  7. Examples of GoF Design Patterns in Java’s core libraries
  8. What is Inversion of Control?
  9. What does “program to interfaces, not implementations” mean?
  10. Does functional programming replace GoF design patterns?
  11. Where do I use delegates? [closed]
  12. What is the dependency inversion principle and why is it important?
  13. What is the meaning and reasoning behind the Open/Closed Principle?
  14. Are there any rules for OOP?
  15. Mediator Vs Observer Object-Oriented Design Patterns
  16. What is composition as it relates to object oriented design?
  17. Differences between Proxy and Decorator Pattern
  18. adapter-Any real example of Adapter Pattern [closed]
  19. Learning/Implementing Design Patterns (For Newbies) [closed]
  20. Switch statements are bad? [closed]
  21. How will I know when to create an interface?
  22. Why can’t I seem to grasp interfaces?
  23. Functional programming vs Object Oriented programming [closed]
  24. Explanation of the UML arrows
  25. Replacing if else statement with pattern
  26. Difference Between Cohesion and Coupling
  27. Polymorphism – Define In Just Two Sentences [closed]
  28. When should I choose inheritance over an interface when designing C# class libraries? [closed]
  29. Multiple Aggregates / Repositories in one Transaction
  30. Why doesn’t generic ICollection implement IReadOnlyCollection in .NET 4.5?

Leave a Comment