Does the single responsibility principal promote flexibility? If not what are the other methods to make your classes more flexible?
By flexibility I mean, a class is able to function correctly at any time with little (or even with no) hassle.
Software Engineering Stack Exchange is a question and answer site for professionals, academics, and students working within the systems development life cycle. It only takes a minute to sign up.Sign up to join this community
Yes. A class that does one thing can be reused in other contexts easily where that responsibilty is necessary; if a class has more than one responsibility, in most cases those other responsibilities create dependencies that might be hard to satisfy in a different context.
Example: A class that does some calculation is easy to reuse. A class that does the calculation and stores the result to the database is hard to reuse in a context without a database, even if you only need the calculation part. Maybe the constructor requires a database connection object, maybe the calculation does the update implicitely.
It's an interesting way to define flexibility. But there's a lot of truth in it, i.e. if a class is robust (as I would call it), you're flexible in using it.
The single responsibility principle doesn't explicitly "promote" robustness. It just say, that a given class should be designed for a single task. Within tighter constraints, robustness is much easier to achieve (as an anology: a swiss army knife is less robust that an Opinel).
The more narrow the task, the less unnecessary implicit assumptions you make, that could break the class when they don't hold, because the client code had no idea they were there.
However the SRP focuses on the inner qualities of a class. What you are interested in is the outer behavior. Such behavior should be abstracted according to DIP and decomposed according to ISP. This is where flexibility comes from: You can plug in implementations at will and implementations are easy to make (no need to implement 50 methods).