Using a strategy pattern and a command pattern

by

I’m including an encapsulation hierarchy table of several of the GoF design patterns to help explain the differences between these two patterns. Hopefully it better illustrates what each encapsulates so my explanation makes more sense.

First off, the hierarchy lists the scope for which a given pattern is applicable, or the appropriate pattern to use to encapsulate some level of detail, depending on which side of the table you start at.

design pattern encapsulation hierarchy table

As you can see from the table, a Strategy Pattern object hides details of an algorithm’s implementation, so the use of a different strategy object will perform the same functionality but in a different way. Each strategy object might be optimized for a particular factor or operate on some other parameter; and, through the use of a common interface, the context can safely work with either.

The Command Pattern encapsulates a much smaller level of detail than an algorithm. It encodes the details needed to send a message to an object: receiver, selector and arguments. The benefit to objectifying such a tiny part of the process execution is that such messages can be invoked along different points of time or location in a general way without having to hard-code its details. It allows messages to be invoked one or more times, or passed along to different parts of the system or multiple systems without requiring the details of a specific invocation to be known before execution.

As is typical for design patterns, they do not require all implementations to be identical in detail to bear the pattern name. Details can vary in implementation and in what data is encoded in the object versus as method arguments.

More Related Contents:

  1. How does the Strategy Pattern work? [closed]
  2. What is the difference between Strategy design pattern and State design pattern?
  3. Why is Singleton considered an anti-pattern? [duplicate]
  4. Ways to eliminate switch in code [closed]
  5. Real World Example of the Strategy Pattern
  6. In a PHP project, what patterns exist to store, access and organize helper objects? [closed]
  7. How do the Proxy, Decorator, Adapter, and Bridge Patterns differ?
  8. Factory Pattern. When to use factory methods?
  9. How will I know when to create an interface?
  10. Why do we need Abstract factory design pattern?
  11. What’s the difference between the Dependency Injection and Service Locator patterns?
  12. Which Typesafe Enum in C++ Are You Using?
  13. Naming Classes – How to avoid calling everything a “Manager”? [closed]
  14. Dependency Injection & Singleton Design pattern
  15. Are utility classes evil? [closed]
  16. Using Command Design pattern
  17. Relational Database Design Patterns? [closed]
  18. Is UnitOfWork equals Transaction? Or it is more than that?
  19. How to implement Builder pattern in Kotlin?
  20. Factory, Abstract Factory and Factory Method
  21. Difference between Bridge pattern and Adapter pattern
  22. Using a Strategy and Factory Pattern with Dependency Injection
  23. What’s the difference between design patterns and architectural patterns? [closed]
  24. Are there any viable alternatives to the GOF Singleton Pattern?
  25. When should you use the singleton pattern instead of a static class? [closed]
  26. What is the difference between Factory and Strategy patterns?
  27. When do we need decorator pattern?
  28. anti-if campaign
  29. Difference betwen Visitor pattern & Double Dispatch
  30. What are `optimistic updates` in front-end development

Leave a Comment