Object-Oriented Analysis and

Design
Topics and skills covered in Course
OOA/D

Patterns UML notation

Topics and Skills

Principles and Requirements

guidelines analysis

Iterative
development with
an agile Unified
Process
 Objectives

• Describe the book goals and scope

• Define OOA/D (Object-Oriented Analysis and Design)
• Illustrate a brief OOA/D example
• Overview UML and visual agile modeling
 Analysis
• Analysis emphasizes an investigation of the problem and requirements, rather
than a solution.

• In software development, we are primarily concerned with two forms of analysis.

• Requirements Analysis is discovering the requirements that a system must
meet in order to be successful.

• Object-Oriented Analysis is investigating the objects in a domain to discover

information important to meet the requirements.
 Design
• Design emphasizes a conceptual solution that fulfills the requirements, rather
than its implementation.
• Design ideas often exclude low-level or obvious details – obvious to the
intended consumers.

• There are subsets of design, including

• architectural design,
• object design,
• database design.
Object-Oriented Analysis and Design (OOA/D)
• During OOA, the emphasis is on finding and describing the objects (or concepts)
in the problem domain, i.e., domain objects.

• During OOD (or simply object design), the emphasis is on defining software
objects and how they collaborate to fulfill the requirements.

• During OOP (OO Programming) or Implementation, design objects are

implemented in a programming language.
• Implementation is also known as Coding or Construction.
Object-Oriented Analysis and Design (OOA/D)
What is OOA/D
• It is a software development approach that emphasize a logical
solution based on objects
The Unified Process (UP)
• A standardized approach to analysis and design helps to ensure that
all necessary tasks are understood and completed in software
development.

• Requirements analysis and OOA/D needs to be presented and practiced in the

context of some development process.
• Here, an agile (light, flexible) approach to well-known Unified Process (UP) is
used as a sample iterative development process.
 Unified Modeling Language (UML)
• UML: Unified Modeling Language
– A standard diagramming notation
– How to write down requirements, design intent, etc. in a
standardized, graphical way so your teammates can understand it
– Software tools for manipulating UML documents
– A visual language for specifying, constructing, and documenting Systems.

• An iterative development process

- The Rational Unified Process
- The “agile” (light, flexible) approach
Three perspectives to apply UML are ...
• Conceptual perspective – the diagrams are interpreted as describing
things in a situation of the real world or domain of interest.

• Specification (software) perspective – the diagrams describe sw

abstractions or components with specifications and interfaces, but no
commitment to a particular language implementation.

• Implementation perspective – the diagrams describe sw

implementations in a particular technology.
Fig 1: Object-orientation emphasizes representation of objects

Plane
visualization of
domain concept tailNumber domain concept

public class Plane

{
representation in an private String tailNumber;
object-oriented
programming language public List getFlightHistory() {...}
}
Three ways people apply UML are ...
• UML as sketch
– Informal and incomplete diagrams (often hand sketched on whiteboards)
created to explore difficult parts of the problem or solution space
– Agile modeling emphasizes UML as sketch.
• UML as blueprint
– relatively detailed design diagrams used either for reverse engineering to
visualize and better understand existing code,
– or for forward engineering to guide for code generation, either manually or
automatically with a tool.
• UML as a programming language
– Complete executable specification of a sw system in UML.
 Short Example: Dice Game
• Software simulates the player rolling two dice
- If total is seven, they win. Otherwise, they lose.
• A few key steps and diagrams in iterative development
1. Define use cases
2. Define domain model
3. Draw interaction diagrams, assign object responsibilities
4. Draw design class diagrams
 1. Use Case: Play a Dice Game
• Player requests to roll the dice. System presents results. If the dice
face value totals seven, player wins; otherwise, player loses.
2. Define domain model (real world objects, not
software objects)
Player Die
1 Rolls 2
name faceValue
1 2
Plays
1

DiceGame
1 Includes

Domain model shows the noteworthy domain concepts as objects, their attributes, and
associations.
3. Draw interaction diagrams, assign object
responsibilities
:DiceGame die1 : Die die2 : Die

play()
roll()

fv1 := getFaceValue()

roll()

fv2 := getFaceValue()

A sequence diagram (a kind of UML interaction diagram) shows the flow of messages between
software objects and thus the invocation of objects.
4. Draw class diagrams (software objects)

DiceGame Die

die1 : Die 1 2 faceValue : int

die2 : Die
getFaceValue() : int
play() roll()

A static view of the class (including its attributes and methods)

definitions is usefully shown with a UML class diagram.