Master the fundamental principles and patterns of object-oriented design
Five fundamental principles of object-oriented programming and design
A class should have only one reason to change, meaning it should have only one job or responsibility.
Software entities should be open for extension but closed for modification.
Objects of a superclass should be replaceable with objects of a subclass without breaking the application.
No client should be forced to depend on methods it does not use. Split large interfaces into smaller ones.
High-level modules should not depend on low-level modules. Both should depend on abstractions.
Reusable solutions to common software design problems
Ensures a class has only one instance and provides a global point of access to it.
Defines an interface for creating objects, but lets subclasses decide which class to instantiate.
Provides an interface for creating families of related objects without specifying their concrete classes.
Separates the construction of a complex object from its representation.
Creates new objects by copying an existing object, known as the prototype.
Allows incompatible interfaces to work together by wrapping an object with an adapter.
Separates an abstraction from its implementation so the two can vary independently.
Composes objects into tree structures to represent part-whole hierarchies.
Adds new functionality to an object dynamically without altering its structure.
Provides a simplified interface to a complex subsystem.
Defines a one-to-many dependency so that when one object changes state, all dependents are notified.
Defines a family of algorithms, encapsulates each one, and makes them interchangeable.
Encapsulates a request as an object, allowing parameterization and queuing of requests.
Provides a way to access elements of a collection sequentially without exposing its representation.
Allows an object to alter its behavior when its internal state changes.