Software Design Principles Quiz

Study Notes

Design Principles are guidelines that help software developers organize methods, data structures, and classes into interconnected frameworks adaptable to changing requirements.
SOLID Principles are a set of five design principles that promote flexible and maintainable software.
- Single Responsibility Principle (SRP): Each software module, class, or interface should have only one reason to change.
  - It ensures that each module is focused on a specific task.
  - Example: An Employee class should only be responsible for employee data and not salary calculations.
- Open-Closed Principle (OCP): Software classes should be designed to allow for behavioral changes by adding new code rather than altering existing code.
  - This enables extending functionality without breaking existing code.
- Liskov Substitution Principle (LSP): Derived classes should be substitutable for their base classes, promoting interchangeable modules and classes.
  - This principle ensures that code remains consistent when using inherited classes.
- Interface Segregation Principle (ISP): Software designers should avoid dependencies on unused features.
  - This encourages focused interfaces that only expose necessary information.
- Dependency Inversion Principle (DIP): Flexible software should depend on abstract classes or interfaces rather than concrete implementations.
  - It promotes loose coupling by relying on abstractions.

Each module, interface, or class should have only one reason to change, focusing its responsibility on a single task.
Changes in requirements often correspond to changes in responsibilities.
Classes with multiple responsibilities should be broken down into smaller, more focused classes.
A class can have multiple members like methods and variables as long as they relate to a single responsibility.