Software Design Principles and Patterns

The Single Responsibility Principle states that a module should have one and only one reason to change, promoting high cohesion and low coupling.

The Open-Closed Principle aims to design software that can be extended with new features without modifying existing code.

The Liskov Substitution Principle states that subclasses should be substitutable for their base classes without altering the correctness of the program.

The Interface Segregation Principle aims to minimize the number of dependencies between modules by defining smaller, more specific interfaces.

Composition over Inheritance suggests that instead of inheriting from a base class, objects should be composed from other objects, promoting flexibility and code reuse.

The Factory Method pattern provides a way to create objects without specifying the exact class of the object that will be created, allowing for greater flexibility and decoupling.

The Abstract Factory pattern provides an interface for creating families of related objects without specifying their concrete classes, promoting interchangeability and decoupling.

The Builder pattern allows the construction of complex objects by separating the construction process from the object itself, making it easier to create different representations of the object.

The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable, allowing the algorithm to be selected at runtime.

The Singleton pattern ensures that a class has only one instance and provides a global point of access to that instance, promoting centralized control and resource management.

The Prototype pattern provides a mechanism to create new objects by copying an existing object, allowing for efficient object creation and reducing the cost of object instantiation.

The Observer pattern defines a one-to-many dependency between objects, allowing one object to notify multiple dependent objects about changes in its state, promoting loose coupling and flexibility.

The Facade pattern provides a unified interface to a set of interfaces in a subsystem, simplifying the interaction with the subsystem and promoting loose coupling.

The Composite pattern allows objects to be composed into tree structures, enabling the representation of hierarchical relationships and providing a uniform interface for manipulating the objects in the tree.

The Decorator pattern allows the dynamic addition or removal of responsibilities from an object, providing a flexible way to modify the behavior of an object at runtime.