Software Design Patterns

Use the factory method to create document objects via a common interface, enabling easy addition of formats like txt, pdf, mobi, and reducing coupling by depending on the factory interface.

Explore how the abstract factory creational design pattern creates families of related objects for ice, fire, and air worlds via a world factory, while keeping object creation isolated from usage.

Explore the builder design pattern to incrementally construct a pizza product, show the final build on screen, and separate construction from representation to improve configurability and readability.

Demonstrates how the prototype design pattern clones circles, rectangles, triangles, and nested layers to enable copy-paste of complex graphics, reducing object creation overhead and increasing design flexibility.

Explore how the singleton design pattern ensures a single instance and a global access point, with an asset manager that caches resources and supports lazy initialization.

Apply the adapter design pattern to unify diverse bank APIs for currency rates, using bank-specific adapters that translate to a shared target interface, boosting modularity and seamless integration.

Learn how the bridge design pattern decouples abstraction from implementation to support a plugin system, enabling independent development of the editor and plugins and easy extension.

Study the composite design pattern by implementing a test interface with leaves and composites that generate random tests via a recursive generate method, highlighting unified interfaces and complexity trade-offs.

Explore the decorator design pattern for game heroes, wrapping a base character with upgrade decorators, attack, speed, health, and double jump, demonstrating four actors and the open-closed principle.

Provide a unified interface to multiple subsystems, hiding their complexity, enabling a single entry point, and promoting loose coupling, though it may introduce rigidity and interface bloat.

Apply the flyweight design pattern to share intrinsic state across thousands of units, reducing memory usage while managing extrinsic state like position and rotation.

Explore the proxy design pattern, where a proxy controls access to a real subject, enabling rate limiting, lazy initialization, caching, and resource management to protect and optimize an API.

Design a chain of responsibility to validate passwords with modular rules like minimum length, maximum length, and special character checks, decoupling the request sender from processing and enabling flexible composition.

Designs undo and redo with the command pattern by creating concrete command objects that execute on a canvas, managed by an invoker and a receiver, with history for undo state.

Explore the interpreter design pattern to evaluate math expressions using plus, minus, and brackets, implemented as modular abstract expressions with terminal, non-terminal, and number classes.

Explore the iterator design pattern to access songs without exposing the collection, using next and hasnext, and implement songs, walker interfaces, and concrete walkers for random, simple, and named order.

Learn how the mediator centralizes communication among smart home devices, reducing direct dependencies. A manager coordinates signals between lights, heating, and air conditioning to simplify maintenance and extensibility.

Learn how the memento design pattern saves and restores a 2048-style game's state, enabling undo, history, and replay by modeling originator, memento, and caretaker.

Explore the observer design pattern by building a game event manager with subscribe, unsubscribe, and notify, enabling a one-to-many, loosely coupled update flow that activates passive skills.

Using the state design pattern, manage a four-stage registration flow: initial, contact information, work experience, and confirmation—via independent stage objects and a context that advances with next or previous actions.

Explore the strategy pattern to build a flexible image filtering engine, where context delegates to interchangeable concrete strategies that implement a common filter interface, enabling runtime algorithm changes.

Learn the template method pattern by using a base bread recipe with a make bread template and abstract steps, implemented by concrete subclasses for different bread types.

Use the visitor pattern to add new operations to units without modifying their classes. Define unit and visitor interfaces with concrete implementations to support actions like attack, defend, and move.