Object-Oriented Programming in Java - Read

processroguishΛογισμικό & κατασκευή λογ/κού

18 Νοε 2013 (πριν από 3 χρόνια και 8 μήνες)

60 εμφανίσεις

BDP
-
1

Venkat Subramaniam

11. Mẫu tương tác

Behavioral Pattern


BDP
-
2

Venkat Subramaniam

Chain of Responsibility
Pattern

“Avoid

coupling

the

sender

of

a

request

to

its

receiver

by

giving

more

than

one

object

a

chance

to

handle

the

request
.

Chain

the

receiving

objects

and

pass

the

request

along

the

chain

until

an

object

handles

it


BDP
-
3

Venkat Subramaniam

Example that would benefit
from

Chain Of Responsibility Pattern


Various types of Controls are used in an
application. Controls handle certain
events while they do not handle others.
Each control may be invoked from other
controls. An event not handled by a
control must be passed on to its parent
control.

BDP
-
4

Venkat Subramaniam

Example using

Chain of Responsibility
Pattern

Event Handler


handleEvent()

Control1


handleEvent()

Control2


handleEvent()

Client

BDP
-
5

Venkat Subramaniam

When to use Chain Of

Responsibility Pattern


More than one object may handle a request,
and the handler isn’t known ahead of time.



One of several objects may be the intended
receiver



Set of objects that handle request is dynamic

BDP
-
6

Venkat Subramaniam

Consequences of using

Chain Of Responsibility


Reduced Coupling



Flexibility in assigning responsibilities


Distributes responsibilities among objects



Receipt isn’t guaranteed

BDP
-
7

Venkat Subramaniam

Chain Of Responsibility

Vs. Other Patterns


Often used with Composite


Parent acts as Successor

BDP
-
8

Venkat Subramaniam

Iterator Pattern

“Provide

a

way

to

access

the

elements

of

an

aggregate

object

sequentially

without

exposing

its

underlying

representation”

BDP
-
9

Venkat Subramaniam

Example that would

benefit from Iterator


Several types of collections are available


List, Set, Queue, Vector



We are interested in performing some
operation on each element in a collection,
without regard to which collection we use

BDP
-
10

Venkat Subramaniam

Example using

Iterator Pattern

Client

Aggregate


CreateIterator()

Iterator


First()

Next()

IsDone()

CurrentItem()

ConcreteIterator

ConcreateAggregate

BDP
-
11

Venkat Subramaniam

When to use Iterator
Pattern


Elements of an Aggregate needs to be accessed
without exposing internal representation of the
aggregate



multiple traversals on an aggregate



uniform traversal on different aggregates

BDP
-
12

Venkat Subramaniam

Consequences of using

Iterator


Supports variations in the traversal



Simplifies interface of Aggregates



More than one traversal may be acting on
the aggregate at any time

BDP
-
13

Venkat Subramaniam

Iterator

Vs. Other Patterns


Often applied to recursive structures such as
Composite



Factory method instantiate appropriate Iterator



Memento used in conjunction with Iterator.
Iterator stores memento internally to capture
the state

BDP
-
14

Venkat Subramaniam

Mediator Pattern

“Define

an

object

that

encapsulates

how

a

set

of

objects

interact
.

Mediator

promotes

loose

coupling

by

keeping

objects

from

referring

to

each

other

explicitly,

and

it

lets

you

vary

their

interaction

independently”

BDP
-
15

Venkat Subramaniam

Example that would

benefit from Mediator


An application is used to design Wheels


The diameter of the rim is restricted by
the Hub diameter


The tire diameter is dependent on the rim


The spokes length needs to be altered if
hub diameter or rim diameter is changed

BDP
-
16

Venkat Subramaniam

Example using

Mediator Pattern

Hub

Rim

Spoke

Tire

Mediator

BDP
-
17

Venkat Subramaniam

When to use Mediator
Pattern


Set of objects communicate in complex well
defined way



You want to reduce interdependency between
objects



Reusing object is difficult if it refers to several
other objects



Behavior distributed between several classes
must be customizable without lot of sub
-
classing

BDP
-
18

Venkat Subramaniam

Consequences of using
Mediator


Localizes behavior that may otherwise be
distributed among several objects



Subclass mediator to change this
behavior



Decouples Colleagues



Replaces many
-
to
-
many interactions with
one
-
to
-
many interaction


Easy to maintain, extend and understand

BDP
-
19

Venkat Subramaniam

Mediator Vs. Other
Patterns


Facade


In Mediator, Colleague objects know Mediator


In Facade subsystem classes do not see Facade



Colleagues may communicate with Mediator
using Observer

BDP
-
20

Venkat Subramaniam

Memento Pattern

“Without

violating

encapsulation,

capture

and

externalize

an

object’s

internal

state

so

that

the

object

can

be

restored

to

its

state

later”

BDP
-
21

Venkat Subramaniam

Example that would benefit

from Memento


You want to let the user modify an object



However the user may cancel the modification



You want to store the internal state of a
complex object to restore it later

BDP
-
22

Venkat Subramaniam

Example using


Memento Pattern

Originator

state

SetMemento(Memento m)

CreateMemento()

Memento

state

GetState()

SetState()

Caretaker

state = m
-
>GetState()

return new Memento(state)

BDP
-
23

Venkat Subramaniam

When to use Memento
Pattern


A snapshot of an object’s state must be saved
to restore later



you do not want to expose the implementation
details of the internal state of an object,
breaking its encapsulation

BDP
-
24

Venkat Subramaniam

Consequences of using

Memento


Simplifies the Originator


Preserves encapsulation boundaries


May be expensive


Defining narrow and wide interfaces


How to ensure only originator accesses
memento’s state


Caretaker is responsible for deleting
memento


Lightweight caretakers may be burdened with
large mementos

BDP
-
25

Venkat Subramaniam

Memento Vs. Other
Patterns


Command


May use mementos to maintain state for undo
operations


Iterator


Mementos can be used for storing internal state of
iterators

BDP
-
26

Venkat Subramaniam

Observer Pattern

Định

nghĩa

mối

quan

hệ

phụ

thuộc

một

nhiều

giữa

các

đối

tượng

sao

cho

khi

một

đối

tượng

thay

đổi

thì

tất

cả

những

đối

tượng

liên

quan

cũng

sẽ

được

thông

báo



tự

động

cập

nhật

theo
.

BDP
-
27

Venkat Subramaniam

Example that would

benefit from Observer


You have several views of a document


Graph View


TabularView


ChartView


The user may change the data of a
document from any of the visible views


You want to keep all the views synched
with the change to the document’s data

BDP
-
28

Venkat Subramaniam

Example using


Observer Pattern

Abstract Document


Attach(View observerView)

Detach(View observerView)

Notify()

View


Update

Observers

GraphView

TabularView

ChartView

YourDocument

BDP
-
29

Venkat Subramaniam

When to use Observer
Pattern


When an abstraction has two aspects one
dependent on the other. Encapsulating these
aspects in separate objects lets you vary and
reuse them independently



Change to one object requires change to others


don’t know how many objects need change


Object is able to notify other objects without
knowing who these objects are
-

don’t want
tight coupling

BDP
-
30

Venkat Subramaniam

Consequences of using

Observer


Abstract the coupling





between observers and subject


Support for broadcast communication


Unexpected updates


May be expensive and untimely


May abstract a hint on the subject change

BDP
-
31

Venkat Subramaniam

Observer Vs. Other
Patterns


Mediator may be used to mediate
between several subjects and observers

BDP
-
32

Venkat Subramaniam

State Pattern

“Allow

an

object

to

alter

its

behavior

when

its

internal

state

changes
.

The

object

will

appear

to

change

its

state”

BDP
-
33

Venkat Subramaniam

Example that would

benefit from State Pattern


A train may run in forward or reverse
mode.


When running in forward mode the head
lights on the front engine are on and the
tail lights on the back engine are on.


When running in reverse mode the
reverse is true.


Acceleration will move the engine forward
or backward depending on the mode

BDP
-
34

Venkat Subramaniam

Example using State
Pattern

Train


turnHeadLights()

turnTailLights()

accelerate()

TrainDirection

currentMode

ForwardMode


turnHeadLights()

turnTailLights()

accelerate()

ReverseMode


turnHeadLights()

turnTailLights()

accelerate()

BDP
-
35

Venkat Subramaniam

When to use State Pattern


An object’s behavior depends on its state and
must change its behavior at run
-
time
depending on that state



Operations have large conditional statements
that depend on the state. State pattern puts
each branch of the conditional in a separate
class.

BDP
-
36

Venkat Subramaniam

Consequences of using
State


Localizes state
-
specific behavior and
partitions behavior for different states



Makes state transitions explicit



State objects can be shared

BDP
-
37

Venkat Subramaniam

State Vs. Other Patterns


Flyweight pattern may be used to share
state which may be singletons.

BDP
-
38

Venkat Subramaniam

Strategy Pattern

“Define

a

family

of

algorithms,

encapsulate

each

one,

and

make

them

interchangeable
.

Strategy

lets

the

algorithm

vary

independently

from

clients

that

use

it”

BDP
-
39

Venkat Subramaniam

Example that would
benefit from

Strategy Pattern


A property may be computed using one of
several methods/algorithms


Each method comes with its own features and
trade
-
offs


For instance, a method may converge towards a
result at a faster rate but may use more memory


Another method may not require as much memory


Design your class such that the client may use
any applicable method to compute property

BDP
-
40

Venkat Subramaniam

Example using


Strategy Pattern

Property


Compute()

MethodForProperty


compute()

Method1


compute()

Method1


compute()

methodToUse

BDP
-
41

Venkat Subramaniam

When to use Strategy
Pattern


Many related classes differ only in their behavior.
Strategy provides a way to configure a class with one
of many behaviors



Use different variants of an algorithm



Algorithm uses data that clients shouldn’t know about.
Strategy avoids exposing complex algorithm
-
specific
data structures



class defines many behaviors and these appear as
multiple conditional statements in its operations.
Instead of many conditionals, move related conditional
branches into their own strategy class.

BDP
-
42

Venkat Subramaniam

Consequences of using
Strategy


Families of related algorithms


Alternative to subclassing


Strategies eliminate conditional statements


Choice of implementations



Clients must be aware of different strategies


Communication overhead between Strategy and
Context


Increased number of objects

BDP
-
43

Venkat Subramaniam

Strategy Vs. Other
Patterns


Often make good Flyweights