List of design patterns
This presentation is the property of its rightful owner.
Sponsored Links
1 / 25

List of Design Patterns PowerPoint PPT Presentation


  • 59 Views
  • Uploaded on
  • Presentation posted in: General

Creational Patterns Abstract Factory Builder Factory Method Prototype Singleton. Structural Patterns Adapter Bridge Composite (Sammy’s Slides) Decorator (Sammy’s Slides) Facade Flyweight Proxy. List of Design Patterns. Behavioral Patterns Chain of Responsibility Command

Download Presentation

List of Design Patterns

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


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

List of Design Patterns

  • Behavioral Patterns

    • Chain of Responsibility

    • Command

    • Interpreter

    • Iterator

    • Mediator

  • Memento

  • Observer

  • State

  • Strategy

  • Template Method

  • Visitor


Factory method class creational

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 creational1

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


Factory method motivation

FACTORY METHODMotivation

docs

Document

Application

Open()

Close()

Save()

Revert()

CreateDocument()

NewDocument()

OpenDocument()

Document* doc=CreateDocument();

docs.Add(doc);

doc->Open();

MyApplication

MyDocument

return new MyDocument

CreateDocument()


Applicability

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.


Factory method structure

FACTORY METHODStructure

Creator

Product

...

product = FactoryMethod()

...

FactoryMethod()

AnOperation()

ConcreteCreator

ConcreteProduct

return new ConcreteProduct

FactoryMethod()


Participants

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

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 example

Factory Example

class 350Z implements Car;// fast car

class Ram implements Car;// truck

class Accord implements Car; // family car

Car 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

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


Applicability1

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 structure

SINGLETONStructure

Singleton

return uniquelnstance

static Instance()

SingletonOperation()

GetSingletonData()

Static uniquelnstance

singletonData


Participants and collaborations

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

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 class

private static MySingleton uniq = new MySingleton();

// private constructor only accessed from this class

private MySingleton() { … }

// return reference to unique instance of class

public static MySingleton getInstance() {

return uniq;

}

}


Adapter pattern

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 pattern1

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

Adapter Example

public interface PriorityQueue {// Priority Queue

void add(Object o);

int size();

Object removeSmallest();

}


Adapter example1

Adapter Example

public 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

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

observers

Observer

Update()

Subject

For all x in observers{

x.Update(); }

attach (Observer)

detach (Observer)

Notify ()

Concrete Observer

Concrete Subject

subject

Update()

GetState()

SetState()

observerState

subjectState

observerState=

subject.getState();

Observer Pattern – Structure


Observer pattern participants

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 changes 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

SetState()

Notify()

Update()

GetState()

Update()

GetState()

Observer Pattern - Collaborations


Observer pattern implementation

public void addObserver(Observer o) {}

Java terminology for Subject.

public void deleteObserver (Observer o) {}

public void notifyObservers(Object arg) {}

Observer Pattern - Implementation

interface Observer {

void update (Observable sub, Object arg)

}

class Observable {

}

public boolean hasChanged() {}


Observer pattern implementation1

Observer Pattern - Implementation

public PiChartView implements Observer {

A Concrete Observer.

void update(Observable sub, Object arg) {

// repaint the pi-chart

}

}

class StatsTable extends Observable{

public boolean hasChanged() {

// override to decide when it is considered changed

}

}


Observer pattern consequences

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)


  • Login