(UNIT I)

Object oriented analysis & design

INTRODUCTION: Object-Oriented Analysis and Design (OOAD) is a methodology for analyzing and
designing a system by visualizing it as a group of interacting, self-contained entities called
objects.(Question no. 1)

JUST FOR INFO: The goal of Object-Oriented Analysis and Design is to improve the quality of the
software system by making it more modular, scalable, and maintainable. OOAD is a crucial step in the
software development life cycle, often performed before the actual coding begins.

SOME KEY TERMINOLGIES IN OOAD:

Object : In Object-Oriented Analysis and Design (OOAD), an "object" is a fundamental concept that
represents a real-world entity with both data (attributes or properties) and behaviors (methods or
functions).

UML: UML stands for Unified Modeling Language, and it is a standardized visual modeling
language used to represent and design software systems. (Question no. 2)

Actors (Question no. 7, 10, 26): An "actor" is an external entity that interacts with a system.
Actors are not part of the system itself but rather represent roles played by external entities,
such as users, other systems, or even hardware devices.

Type of Actors:

Primary Actors : are the main external entities that directly interact with the system
to achieve a specific goal or execute a use case.

Secondary Actors: are entities that provide services or support to the system but are
not the primary users of the system.

Tertiary Actors: are entities that provide services or support to the system but are
not the primary users of the system

Scenario: In OOAD, a "scenario" refers to a specific sequence of events or a narrative that

describes a potential interaction between the system and its actors.(Question no. 8)

Example: Consider a scenario for an online shopping system:

Use Case: Purchase Items

Scenario:

• User logs in to the system.

• User browses items and adds them to the shopping cart.
 • User proceeds to checkout and provides shipping information.

Use Case: In OOAD, a "use case" is a representation of a discrete functionality or behavior

that a system provides to its users (actors). Use cases are a way of capturing and specifying
the requirements of a system from the perspective of its end-users. (Question no.9)

…….. [Note: Explain (a) Actors (b) Scenarios (c) Use cases] (Question no. 25)…….

Inception: In OOAD ,"inception" refers to the initial phase or stage of a software

development project.(Question no. 6)

for info: The inception phase is part of the larger software development life cycle and
represents the starting point where the project is initiated, and the initial requirements and
scope are defined.

Unified Process (Question no. 20, 29, 31): Unified Process (UP) in OOAD is a software
development methodology that provides a framework for iterative and incremental
development. It is an adaptable process that emphasizes flexibility, collaboration, and the
iterative refinement of a software system throughout its development life cycle.

Phases of Unified process:

1) Inception: During the inception phase, the primary goal is to establish the project's
vision, scope, and feasibility. This phase involves understanding the high-level
requirements, defining the initial use cases, identifying major risks, and creating a
preliminary project plan.
2) Elaboration: The elaboration phase is focused on refining the project vision and
establishing a solid architecture for the system. It involves a more detailed analysis of
the requirements, further risk assessment, and the development of a stable
architecture that can serve as a foundation for subsequent development.
3) Construction: The construction phase is where the actual coding and
implementation of the system occur. It involves building, integrating, and testing the
system incrementally. The emphasis is on delivering functionality in successive
iterations.
4) Transition: The transition phase focuses on deploying the system to end-users or
customers. It involves user training, final testing, and the transition of the system
from development to production

Diagram for phases of Unified process:

 Different types of diagrams in UML
[ note: it covers Question no. 4, 12, 13, 16, 17, 22, 27, 28, 33,35]

In OOAD, several types of diagrams are used to model different aspects of software system.

1) Use case diagram :

Use case diagrams depict the interactions between actors (external entities, such as
users) and the system. They focus on the functional requirements of the system and
show how users interact with the system to achieve specific goals.

How to draw it :

o Identify the Actors (role of users) of the system.

o For each category of users, identify all roles played by the users relevant to the system.
o Identify what are the users required the system to be performed to achieve these goals.
o Create use cases for every goal.
o Structure the use cases.
o Prioritize, review, estimate and validate the users.

Example:
2) Class Diagram:
Class diagrams represent the static structure of the system by illustrating classes,
their attributes, methods, and relationships. They provide a blueprint for designing
the data and object-oriented structure of the system.

How to draw it:

o The name of the class diagram should be meaningful to describe the aspect
of the system.

o Each element and their relationships should be identified in advance.

o Responsibility (attributes and methods) of each class should be clearly

identified

o For each class, minimum number of properties should be specified, as

unnecessary properties will make the diagram complicated.

o Use notes whenever required to describe some aspect of the diagram. At the
end of the drawing it should be understandable to the developer/coder.

o Finally, before making the final version, the diagram should be drawn on plain
paper and reworked as many times as possible to make it correct.
 Example:

3) Activity Diagram:
Activity diagrams represent workflows and business processes within the system.
They illustrate the flow of activities and decision points, helping to model the
dynamic aspects of the system.

How to draw it:

o Figure out the action steps from the use case
o Identify the actors who are involved
o Find a flow among the activities
o Add swimlanes(partition or section)

Some important notations for activity diagram:

Example:
4) State diagram:
State diagrams model the states that an object or a system can be in and the
transitions between these states in response to events. They are useful for
representing the lifecycle of objects

How to draw:
o Identify the initial state and the final terminating states.
o Identify the possible states in which the object can exist (boundary values
corresponding to different attributes guide us in identifying different states).
o Label the events which trigger these transitions.

Example:

5) Component Diagram:
Component diagrams depict the physical structure of the system by illustrating the
software components and their relationships. They help visualize how the software is
organized at a high level.

Example:
 Object oriented software development life cycle (Question no. 36)

Object-Oriented Programming (OOP) is a programming paradigm that uses objects, which are
instances of classes, to design and organize code. The development life cycle in an Object-Oriented
approach typically involves the following stages:

(Question No. 3 : What is analysis and design.)

Analysis:

• Identify and understand the problem domain.

• Define the requirements for the system.
• Identify the key objects and their relationships.

Design:

• Create a conceptual model of the system using tools like UML (Unified Modeling Language).
• Define classes and their attributes (data members) and behaviors (methods/functions).
• Establish relationships between classes (e.g., inheritance, composition).
• Create diagrams such as class diagrams, sequence diagrams, and use case diagrams.

Implementation:

• Write code based on the design.

• Implement classes, methods, and relationships.
• Use appropriate design patterns to solve common problems.
• Ensure that the code is modular, reusable, and follows best practices.

Testing:

• Conduct unit testing to verify the functionality of individual classes and methods.
• Perform integration testing to ensure that components work together as expected.
• Validate that the system meets the specified requirements.

Deployment:

• Deploy the application to the target environment.

• Ensure that all necessary dependencies are satisfied.
• Monitor the system for any issues and address them promptly.
Maintenance and Updates:

• Address bugs and issues discovered post-deployment.

• Make updates and enhancements to the system as needed.
• Ensure that the system evolves to meet changing requirements.

Throughout the development life cycle, OOP principles such as encapsulation, inheritance, and
polymorphism guide the organization and structure of the code. These principles contribute to
creating code that is modular, extensible, and easier to maintain over time. The iterative and
incremental nature of the OOP development life cycle allows for flexibility and adaptation to
changing requirements.