You are on page 1of 17

By

Syed Feroz Zainvi


Writing from:
http://www.computer-science-notes.blogspot.com
Š To identify the classes which perform a use
case’s flow of events.
Š To distribute the use case behavior to those
classes, using use-case realizations.
Š To identifyy the responsibilities,
p attributes and
associations of the classes.
Š To note the usage of architectural mechanisms
For each use-case:
Š Create the Use-Case Realization
Š Supplement the Use-Case Description
Š Find Analysis Classes from Use
Use-Case
Case Behavior
Š Distribute Behavior to Analysis Classes
Š Describe Responsibilities
Š Describe
D rib Attributes
Attribut and
nd A
Associations
i ti n
For each iteration:
Š Reconcile the Use-Case Realizations
Š Qualify Analysis Mechanisms
Š Establish Traceability
Š Review the Results
To create the modeling element used to express the behavior of the use case.

Use Analysi
Case Use Case Realizations s/Desig
Model
d l nModel
d l

Requirements
q Analysis/
y /
Centric Design
Activities Activities
To Do

Use Case
Use Case
Realization
Realizes
To capture additional information needed in order to understand the
q
required y
internal behavior of the system y be missing
that may g from the
use-case
The ATM validates the Bank Customer’s card

The ATM sends the customer’s account number and the PIN to the
ATM Network to be validated. The ATM Network returns success if
the
h customer numberb and d the
h PIN match h and
d the
h customer is
authorized to perform transactions, otherwise the ATM Network
returns failure

Use case description should clearly describe the internal behavior of the system
in an unambiguous way
To-Do:
•Do not describe at all
•Supplement existing description of Flow of Events
•Describe it as complete textual flow
To identify a candidate set of model elements (analysis classes) which will be
capable of performing the behavior described in use cases.

Required Behavior Model


(Functional + El
Elementst How the System
Supplemental (Analysis Works?
Requirements Classes)

Elaboration
•Roles in UC Î Behavior
A li i Specific
•Application S ifi Behavior
B h i Æ Boundary
B d & Control
C l Cl
Classes
•Domain Specific Behavior Æ Entity Classes
To Do
y classes
•Identity
•Name them
•Describe them briefly
To express the use-case behavior in terms of collaborating analysis classes. To
determine the responsibilities of analysis classes.

To Do
•Identify analysis classes
Create at least one interaction diagram (collaboration/sequence)
•Create
•Illustrate interactions between analysis class in interaction diagram
•Include classes that represent of the control classes of used use-cases
Š Entity Classes
ƒ Models information & associated behavior that is
generally long lived
ƒ May y reflect some real world entityy or performs tasks
internal to the system
ƒ Independent of its surroundings & may be
independent of application as well
ƒ Noun or noun phrases occurring in flow of events of
a use-case can be used for this ((those describing
g
responsibility of use-case)
ƒ Found early in elaboration phase
ƒ Al called
Also ll d “Domain
“D i Classes”
Cl ” as they
h abstract
b reall
world entities
Š Boundary Classes
ƒ Handle communication between surroundings g and
inside of the system
ƒ Can provide interface to a user or another system &
thus models system interfaces
ƒ Surrounding dependent
ƒ Each physical actor/scenario pair is examined to
discover boundary classes
ƒ Chosen in elaboration phase
ƒ Can also be added to facilitate communication with
other system
ƒ Provide “Look
Look and Feel”
Feel of the system
ƒ Refined later to take into consideration the chosen
communication protocol
Š Control Classes
ƒ q
Model sequencing g behavior specific
p to one or more
use-cases
ƒ Co-ordinate the events needed to realize the
behavior specified in the use-case
use case
ƒ They “run” the use case i.e. represent dynamics of
the use case
ƒ Are application dependent
ƒ In early stages of elaboration phase, a control class is
added
dd d for
f each h actor/use
/ case pair. Later, may be
b
eliminated, combined or split.
ƒ Responsible for flow
flow-of-events
of events in use case
ƒ Use is very subjective and hence, should be carefully
chosen as data & behavior should not separate out
To describe the responsibilities of a class of objects identified from use-
case behavior
Responsibilities
•Actions that object can perform
K l d that
•Knowledge th t object
bj t maintains
i t i & provides
id to
t other
th objects
bj t
•Neither under loaded nor overloaded
•No obvious responsibilities to be listed

To Do
Find Responsibilities
•Find
•Using Interaction Diagrams
•Checking related non-functional requirements
•Documenting Responsibilities
N
•Name
•Description: what object does to fulfill responsibility & returned
results
Analysis
y class diagram
g

Describe Event
Establish
E t bli h A
Associations
i ti D
Dependencies
d i
Define Attributes •Study links in •Multiple objects to
•Attributes stores info interaction diagrams: know about an event
y
•By-value,, owned,, -Global scope,
p , object
j •Without knowledge g to
get/set passing, permanent, source
•Separate class for •Focus on •Subscribe association
complex behavious association/aggregation used
•Has: •Give associations: S b ib d t
•Subscribed-to objects
bj t
•Name: noun -Role names are usually entity
•Decscrip:optional -Description objects
•Data Type:simple -Multiplicity (0..*,3..8,) •Here onlyy noting;
g how
comes in design
To reconcile the individual use-case realizations and identify a set of analysis
classes with consistent relationships

To Do:
•Identify Consistencies
•Resolve them
•Remove duplicates
d l
•Propagate relationships correctly
•Analysis classes should best represent problem & solution domain
can be selected
To Do: E.g.
g Persistence
e s s e ce Mechanism
ec a s Used By
y Flight
g
•Identify analysis mechanisms
•Helpful parameters:
•Instances of analysis class
Th i size
•Their i
•Frequency of access
•Expected life span
Q
•Qualifyy relevant characteristics
•Be may be informal
To maintain the traceability relationships between the Analysis Model
and other models.

E Boundary
E.g. B d Classes
Cl ÍÎ GUIs
GUI
To verify that the analysis objects meet the functional requirements made
on the system.
To verify that the analysis objects and interactions are consistent.

To Do:
•Review the results informally
•Conclude use-case
use case analysis activity
•Verify using checkpoints for output artifacts
Š Guidelines Use Case Realization
Š Guidelines Analysis Classes
Š Guidelines Collaboration Diagrams
Š Guidelines Sequence Diagrams
Š Use Case Analysis using Rational Rose ®

Keep visiting: http://www.computer-science-notes.blogspot.om


h // i bl

Also linked thru:


http://www crossroadsbyzainvi blosgpot com
http://www.crossroadsbyzainvi.blosgpot.com