1. Review: Design Pattern Structure
A design pattern has a name
So when someone says “Adapter” you know what they mean
So you can communicate design ideas as a “vocabulary”
A design pattern describes the core of a solution to a recurring design problem
So you don’t have to reinvent known design techniques
So you can benefit from others’ (and your) prior experience
A design pattern is capable of generating many distinct design decisions in different circumstances
So you can apply the pattern repeatedly as appropriate
So you can work through different design problems using it

2. Three Design Patterns Involving Classes
Adapter (structural)
Converts an interface you have into one you want
Memento (behavioral)
Externalizes the state of an object
Observer (behavioral)
Tells objects about changes in another object

3. Structural Patterns Help define fixed structural relationships
Between classes, and their associations
Emphasis on the class diagrams
Example
Adapter pattern

4. Inconsistent Interfaces
Challenge
Different code bases are often written by different developers, at different times, with different design goals
Interfaces expected by one piece of code are not always the same as those provided by the other code that’s available
Motivates use of the Adapter pattern
Provides a class that exposes the interface that’s needed
That interface is implemented using calls to methods of the existing object(s)
A related pattern called “Wrapper Façade” provides a similar capability by wrapping functions (e.g., socket calls, etc.)

5. Adapter Pattern Problem Context Solution Core
Have an object with an interface that’s close to (but is not exactly) what we need
Context
Want to re-use an existing class
Can’t change its interface
It’s impractical to extend class hierarchy more generally
Solution Core
Wrap a particular class or object with the interface needed (2 forms: class form and object forms)

6. Adapter Structure (Class Form)
Interface
Impl
method () = 0;
impl_method ();
public
private
Adapter
method () {
impl_method (); };
Interface abstract base class provides desired interface
Impl concrete class provides the implementation
Adapter glues them together via inheritance

7. Adapter Structure (Object Form)
Interface
method () = 0;
impl_
Adapter
Impl
method () {
impl_->impl_method(); };
impl_method ();
Interface abstract base class provides desired interface
Impl concrete class provides the implementation
Adapter glues them together via delegation

8. Behavioral Patterns Help define dynamic behavioral relationships
Between objects at run-time
Emphasis is on interactions among objects
Examples
Memento pattern
Observer pattern

9. Adding State Persistence
Challenge
Want to save and restore an object’s state
For example, between different runs of a program
Motivates use of the Memento pattern
Serialize an object’s state into an opaque “cookie”
Format of cookie can be tailored to storage format
Can send it to a file, a caretaker object, another computer
Can reconstitute object from its memento later/elsewhere

10. Memento Pattern Problem Context Solution Core Consequences
Want to externalize state of an object without violating encapsulation
Context
A snapshot of object state is needed
Providing a state interface would violate encapsulation
Solution Core
Create a memento class with methods to get, set state
Provide an opaque representation of state itself
Consequences
Can use memento to send object state over a socket,
save it in a file, put it into a checkpoint/undo stack, etc.

11. Inter-dependent Object Behaviors
Challenge: need to coordinate object state changes
For example, a sensor may record current temperature
Other objects (e.g., thermostat) need to know when the temperature changes
Motivates use of the Observer pattern
Helps to keep objects mostly independent
Separates registration, notification, and actions
But, still allows appropriate coordination among objects

12. Observer Pattern Problem Context Solution core Consequences
Need to update multiple objects when the state of one object changes
Context
Multiple objects depend on the state of one object
Set of dependent objects may change at run-time
Solution core
Allow dependent objects to register with object of interest, notify them of updates when state changes
Consequences
When observed object changes others are notified
Useful for user interface programming, other applications

13. Observer Pattern Behavior
<<Subject>>
<<Observer>>
<<Observer>>
register()
register()
(optional)
∆ state
notify()
update()
update()