List of Design Patterns
-
Upload
aladdin-horton -
Category
Documents
-
view
21 -
download
0
description
Transcript of List of Design Patterns
List of Design Patterns• Creational Patterns
– Abstract Factory– Builder– Factory Method– Prototype– Singleton
• Structural Patterns– Adapter– Bridge– Composite (Sammy’s Slides)– Decorator (Sammy’s Slides)– Facade– Flyweight– Proxy
• Behavioral Patterns– Chain of Responsibility– Command– Interpreter– Iterator– Mediator
– Memento– Observer– State– Strategy– Template Method– Visitor
FACTORY METHOD (Class Creational)
• Intent:– Define an interface for creating an object, but
let subclasses decide which class to instantiate.
– Factory Method lets a class defer instantiation to subclasses.
FACTORY METHOD (Class Creational)
• Motivation:– Framework use abstract classes to define and
maintain relationships between objects– Framework has to create objects as well -
must instantiate classes but only knows about abstract classes - which it cannot instantiate
– Factory method encapsulates knowledge of which subclass to create - moves this knowledge out of the framework
docsDocument
Open()
Close()
Save()
Revert()
Application
MyDocument
CreateDocument()
NewDocument()
OpenDocument()
MyApplication
CreateDocument()
Document* doc=CreateDocument();docs.Add(doc);doc->Open();
return new MyDocument
FACTORY METHODMotivation
Applicability
• Use the Factory Method pattern when– a class can´t anticipate the class of objects it
must create.– a class wants its subclasses to specify the
objects it creates.– classes delegate responsibility to one of
several helper subclasses, and you want to localize the knowledge of which helper subclass is the delegate.
Product
Creator
ConcreteProduct
FactoryMethod()
AnOperation()
ConcreteCreator
FactoryMethod()
...product = FactoryMethod()...
return new ConcreteProduct
FACTORY METHODStructure
Participants
• Product– Defines the interface of objects the factory method creates
• ConcreteProduct– Implements the product interface
• Creator– Declares the factory method which returns object of type product– May contain a default implementation of the factory method– Creator relies on its subclasses to define the factory method so
that it returns an instance of the appropriate Concrete Product.• ConcreteCreator
– Overrides factory method to return instance of ConcreteProduct
Factory Pattern
• Example– Car Factory produces different Car objects– Original
• Different classes implement Car interface• Directly instantiate car objects• Need to modify client to change cars
– Using pattern• Use carFactory class to produce car objects• Can change cars by changing carFactory
Factory Exampleclass 350Z implements Car; // fast carclass Ram implements Car; // truckclass Accord implements Car; // family carCar fast = new 350Z(); // returns fast car
public class carFactory { public static Car create(String type) { if (type.equals("fast")) return new 350Z(); if (type.equals("truck")) return new Ram(); else if (type.equals(“family”) return new Accord(); }}
Car fast = carFactory.create("fast"); // returns fast car
SINGELTON (Object Creational)
• Intent:– Ensure a class only has one instance, and provide a
global point of access to it.• Motivation:
– Some classes should have exactly one instance(one print spooler, one file system, one window manager)
– A global variable makes an object accessible but doesn’t prohibit instantiation of multiple objects
– Class should be responsible for keeping track of its sole interface
Applicability
• Use the Singleton pattern when– there must be exactly one instance of a class,
and it must be accessible to clients from a well-known access point.
– when the sole instance should be extensible by subclassing, and clients should be able to use an extended instance without modifying their code.
Singleton
return uniquelnstancestatic Instance()
SingletonOperation()
GetSingletonData()
Static uniquelnstance
singletonData
SINGLETONStructure
Participants and Collaborations
• Singleton:• Defines an instance operation that lets
clients access its unique interface• Instance is a class operation (static in Java)• May be responsible for creating its own
unique instance• Collaborations:• Clients access a Singleton instance solely
through Singleton’s Instance operation.
Singleton Example
public class Employee { public static final int ID = 1234; // ID is a singleton} public final class MySingleton {
// declare the unique instance of the classprivate static MySingleton uniq = new MySingleton();// private constructor only accessed from this classprivate MySingleton() { … }// return reference to unique instance of classpublic static MySingleton getInstance() { return uniq;}
}
Adapter Pattern
• Definition– Convert existing interfaces to new interface
• Where to use & benefits– Help match an interface– Make unrelated classes work together– Increase transparency of classes
Adapter Pattern
• Example– Adapter from integer Set to integer Priority
Queue– Original
• Integer set does not support Priority Queue
– Using pattern• Adapter provides interface for using Set as Priority
Queue• Add needed functionality in Adapter methods
Adapter Example
public interface PriorityQueue { // Priority Queue
void add(Object o); int size(); Object removeSmallest();}
Adapter Examplepublic class PriorityQueueAdapter implements PriorityQueue { Set s; PriorityQueueAdapter(Set s) { this.s = s; } public void add(Object o) { s.add(o); } int size() { return s.size(); } public Integer removeSmallest() { Integer smallest = Integer.MAX_VALUE;
Iterator it = s.iterator(); while ( it.hasNext() ) { Integer i = it.next(); if (i.compareTo(smallest) < 0) smallest = i; } s.remove(smallest); return smallest; }}
Observer Pattern – Classification & Applicability
• A behavioral (object) pattern:– Concerns objects and their behavior.
• Applicability– Vary and reuse 2 different abstractions
independently.– Change to one object requires change in (one
or more) other objects – whose identity is not necessarily known
Observer Pattern – Structure
Subject
attach (Observer)
detach (Observer)
Notify ()
Observer
Update()
Concrete Observer
Update()
observerState
Concrete Subject
GetState()
SetState()
subjectState
observers
subject
For all x in observers{ x.Update(); }
observerState= subject.getState();
Observer Pattern - Participants
• Subject– Has a list of observers; – interfaces for attaching/detaching an observer
• Observer– An updating interface for objects that gets notified of c
hanges in a subject.
• ConcreteSubject– Stores state of interest to observers– Sends notification when state changes.
• ConcreteObserver– Implements updating interface.
Observer Pattern - Collaborations
:ConcreteSubject :ConcreteObserver-1 :ConcreteObserver-2
GetState()
Notify()
Update()
SetState()
GetState()
Update()
Observer Pattern - Implementation
interface Observer {
void update (Observable sub, Object arg)}
Java terminology for Subject.
public void addObserver(Observer o) {}
public void deleteObserver (Observer o) {}
public void notifyObservers(Object arg) {}
class Observable {
…
}
public boolean hasChanged() {}
Observer Pattern - Implementation
public PiChartView implements Observer {
void update(Observable sub, Object arg) {
// repaint the pi-chart
}}
A Concrete Observer.
class StatsTable extends Observable{
public boolean hasChanged() {
// override to decide when it is considered changed
}
}
Observer Pattern - Consequences
• Abstract coupling between subject and observer. (subject need not know concrete observers)
• Support for broadcast communication (all observers are notified)
• Unexpected updates (observers need not know when updates occur)