Design Patterns - University of Waterloo · Design challenge: the observers need ... Very simple...
Transcript of Design Patterns - University of Waterloo · Design challenge: the observers need ... Very simple...
Creational Structural Behavioural
Abstract FactoryBuilder
Factory MethodPrototypeSingleton
AdapterBridge
CompositeDecoratorFacade
FlyweightProxy
Chain of ResponsibilityCommandInterpreter
IteratorMediatorMementoObserver
StateStrategy
Template MethodVisitor
Creational Structural Behavioural
Singleton
AdapterBridge
Composite
Facade
CommandInterpreter
Observer
Strategy
Visitor
Observer (Publish/Subscribe)
Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
Observer (Publish/Subscribe)
Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
Observer (Publish/Subscribe)
Design challenge: the observers need to know more
Solution 1: add parameters to notify method
public interface Observer {public notify(String acct, double amt, String emailAddr, String overdraftAcct);}public Audit implements Observer {public void notify(String auditedAccount, double overdrawnAmount, String ignoreEmailAddr, String ignoreOverdraftAcct) {// write info to log, take other appropriate action}}
Observer (Publish/Subscribe)
Complications:Need to add new parameters in all existing ListenersMay be sending unused data to Listeners
Observer (Publish/Subscribe)
Design challenge: the observers need to know more Solution 2: callbacks
Observer (Publish/Subscribe)
Complications:May reveal too much information to Listeners
Solution: pass a Msg object that encapsulates the Account information instead of passing Account object by reference
Each listener will be blocked until previous listeners are done (in single-threaded situations) The state of the objects passed to Listeners might change in concurrent applications
Observer (Publish/Subscribe)Design challenge: the observers need to know moreSolution 3: reify the event
Observer (Publish/Subscribe)Design challenge: the observers need to know moreSolution 4: new Observer interface
Very simpleHow to distinguish between the old (legacy) interface and the new Observer interface
ex. The new interface extends old interface and adds two new methods.
Strategy
Vary the algorithm independently of the clients who use it. 1. Who chooses the strategy?
2. Are strategy objects mutable? Examples:
Strategy used to sort a list of numbers - if known the list is almost sorted, use merge sort; otherwise use quicksort
Strategy
Mutable Strategy Objectseasier to return more complex resultsneed to be instantiated for each use
Stateless Strategy Objectsreusablere-entrantsimpler API usage rulescan be Singleton
Singleton
Advantagesconveniencecontrolled accessreduced namespacecan substitute alternativesmore flexible than static methods
Issues global variables
make testing harder synchronization may reduce parallelism memory leaks
initialization
class-loaders vs VMs distributed systems may hinder re-use
Singleton: traditional implementation
public class Singleton { private static final Singleton INSTANCE = new Singleton();
// Private constructor prevents external instantiation private Singleton() {}
public static Singleton getInstance() { return INSTANCE; }}
Singleton: safer initialization [Pugh]
public class Singleton { // Private constructor prevents external instantiation private Singleton() {}
/** * SingletonHolder is loaded on the first execution * of Singleton.getInstance() or the first access to * SingletonHolder.INSTANCE, not before. */ private static class SingletonHolder { static final Singleton INSTANCE = new Singleton(); }
public static Singleton getInstance() { return SingletonHolder.INSTANCE; }}
Adapter
To consider:1. Large delta between local & foreign => facade2. Exceptions?3. Instantiation?4. Does the adapter need to add functionality?
example: SWT and Swing.5. Stateful? Probably shouldn't be.
Adapter vs Bridge
Adapterconnection unforseeninterfaces already exist
Bridgeconnection forseenneed to be able to subclass both abstraction and implementation
Other patterns you need to know
Lectures so far & Lab1 visitorinterpreteriteratorcomposite
Reading & Future Lecturefacade [cf Bowman]command
Comprehension Questions
What are some ways of adapting an existing Observer class when more information is needed by a type of event? What are some pros and cons of these methods?Name some benefits and downsides of mutable and stateless Strategy objects.What are some issues with the Singleton pattern?Name some uses of the Strategy, Adapter, Singleton, Bridge, and Observer patterns. In GUI Framework, when a button is pressed, an OnButtonPressed event is received. What type of pattern is being used?
Answer: Observer Design Pattern is used. All the Observers (or Listeners in Java) are notified.
Comprehension Questions
Why is it generally considered bad practice to have mutable Singleton classes?What are some differences between the Adapter and the Bridge design pattern? Give an example of both to support your answer.In Java, switching between different layouts using a context makes use of what design pattern?
Answer: Strategy Design Pattern