GoF Patterns Ch. 26

Adapter Pattern Problem: how to resolve incompatible interfaces, or provide a stable interface to similar components with different interfaces? Solution: Convert the original interface of a component into another interface, through an intermediate adapter object.

Adapter Next gen POS needs to interface with several third-party services: tax calculators, credit authorization services, inventory systems, and accounting. Each has a different API which cannot be changed. Add indirection: adapts to external, has consistent internal I/F - adapter

Using the Adapter Includes pattern in type name Façade – wrap access to system or subsystem with a single object Adapter supports protected variations – changing ext interfaces, indirection, polymorphism

Most design patterns are seen as specialization of GRASP Adapter: indirection and protected variation that uses polymorphism

Updating the domain model! Discover noteworthy domain concepts after creating a new class

Factory Problem: Who should be responsible for creating objects when there are special considerations, such as complex creation logic, a desire to separate the creation responsibilities for better cohesion, etc? Solution: Create a Pure Fabrication object called Factory that handles the creation. Design to maintain separation of concerns, the more distinct the concerns, the more cohesive is the purpose! Factory object is designed to create objects separate responsibility into a cohesive helper object hide complex creation logic allow performance-enhancing memory management through caching or recycling

Factory Dynamically loads the class!!! – in this case from an external property Protected variations if adapter changes, without changing source code of factory we can create new adapters! Factory ~ Singleton

Singleton Problem: Exactly one instance of a class is allowed in a “singleton”. Objects need a global and single point of access. Solution: Define a static method of the class that returns the singleton. Who creates the factory and how is it accessed? Static is a form of visibility: we do not need to pass the object as a parameter to be able to access its methods

Singleton Class X defines a static method getInstance that itself provides an instance of X Lazy (preferred, less work!, check if null, then init) vs Eager initialization

Implicit getInstance SIngleton Wy not make service methods static methods of the class itself? Static methods not polymorphic, do not permit overriding Related: factory, façade

Adapter, Factory, & Singleton Building blocks To handle the problem of varying interfaces for external services, let’s use Adapters generated from a Singleton Factory

Strategy Problem: How to design for varying, but related, algorithms or policies? How to design for the ability to change algorithms or policies? Solution: Define each algorithm/policy/strategy in a separate class with a common interface.

Strategy Multiple sale pricing strategy classes, polymorphic getTotal method

Strategy Application

Creating Strategy with Factory

Creating Strategy with Factory

Creating a strategy

Composite Problem: How to treat a group or composition structure of bjects the same way (polymorphically) as a non-composite (atomic) object? Solution: Define classes for composite and atomic objects so that they implement the same interface.

Composite Outer composite object contains a list of inner objects and both the outer and inner objects implement the same interface. CompositeBestForCustomerPRicingStrategy inherits the attribute pricing Strategies

Composite

Creating Composite Strategy

Pricing strategy for customer discount

Pricing strategy for customer discount Based on polymorphism and protected variations

Recap - GoF Adapter Factory Singleton Strategy Composite Still left: Façade Observer

Facade Problem: A common, unified interface to disparate set of implementations or interface such as within a subsystem is required. There may be undesirable coupling to many things in the subsystem, or the implementation of the subsystem may change. What to do? Solution: Define a single point of contact to the subsystem, a façade object that wraps the subsystem. This façade object presents a single, unified interface and is responsible for collaborating with the subsystem components.

Façade Front end interface, hides subsystem behind an object Singleton pattern Separation of concerns

Observer

Observer (Publish-Subscribe) Problem: Different kinds of subscriber objects are interested in the state changes or events of a publisher object, and want to react in their own unique way when the publisher generates an event. Moreover, the publisher wants to maintain low coupling to the subscribers. What to do? Solution: Define a subscriber or listener interface. Subscribers implement this interface. The publisher can dynamically register subscribers who are interested in an event and notify them when an event occurs.

Observer

Observer

Practice with patterns http://www.vincehuston.org/dp/patterns_quiz.html http://www.dofactory.com/net/design-patterns https://www.proprofs.com/quiz-school/story.php?title=Quiz-GoF- Design-Patterns-1&user_name=I https://www.tutorialspoint.com/design_pattern/design_pattern_online _quiz.htm