Object Oriented Analysis

 

Unit -6 Object Oriented Analysis

 Iterative development means building the software step by step through repeated iterations, where each iteration goes through requirements analysis, design, implementation, and testing using object-oriented concepts.
· Each iteration adds more classes, objects, and functionality, improves the system design, and reduces risk.

· This approach allows continuous user feedback, better management of complexity, and gradual development of a robust object-oriented architecture.

Instead of defining all requirements, OOSE focuses on identifying use cases early and refining them across iterations.
 
Rational Unified Process (RUP) is a structured, iterative software development process that provides guidelines for building object-oriented systems.
 

 It divides the development life cycle into four phases—
· Inception,
· Elaboration,
· Construction,
· Transition—with each phase consisting of one or more iterations.

· RUP is use-case driven, architecture-centric, and risk-focused, meaning system requirements are captured as use cases, a strong architecture is established early, and major risks are addressed in early iterations.

· This process supports incremental development, continuous testing, and clear documentation, making it suitable for medium to large and complex software projects.

Inception phase of the Rational Unified Process (RUP), the main goal is to define the project scope and feasibility. During this phase, key system requirements are identified at a high level, major use cases are outlined, and critical risks are recognized.
·  A basic business case is prepared, along with initial project planning, cost estimation, and resource allocation.

·  The inception phase ensures that all have a clear understanding of the project objectives.

 Understanding requirements is the process of clearly identifying and analyzing what the users expect from a software system.

· It involves gathering requirements through discussions, interviews, observations, and use cases, then organizing and validating them to avoid ambiguity.

·The goal is to understand what the system should do, not how it will be built, ensuring that the final software meets user needs and reduces the risk of errors and rework later in development.

The use case model from Inception to Elaboration in the Rational Unified Process (RUP) evolves a requirement.

· In the Inception phase, the use case model is high-level and incomplete.
· the most important use cases are identified to define the system scope and understand how users will interact with the system.

· use cases help estimate cost, identify major risks.
In the Elaboration phase, the use case model is refined and expanded. system use cases are identified and described in detail, including main flows and alternative flows. The use case model is used to validate requirements, drive system architecture, and address high-risk functionality.
 

Unit -7 Object-Oriented Design (OOD)

Object-Oriented Design (OOD) is a way of designing software by organizing it around objects rather than functions &logic.
An object represents a real-world entity and contains:

• Data (attributes / properties)
• Behaviours (methods / functions)

Four Main Principles of OOD:

1.   Encapsulation – Hide internal data

2.   Abstraction – Show only essential details

3.   Inheritance – Reuse code from other classes

4.   Polymorphism – Same interface, different behaviour

 Goal of OOD: To Build software that is modular, reusable, scalable, and easy to maintain.

Booch Method -: The Booch Method is an object-oriented design (OOD) approach created by Grady Booch.

Key Points:

• Focuses on identifying classes and objects
• Uses diagrams to model systems
• Follows an iterative development process
• Helped form the Unified Modelling Language (UML)

It is a diagram-based OOD method for designing object-oriented systems.

Booch Diagrams

The Booch method introduced several diagram types (later influenced UML):

• Class Diagram
• Object Diagram
• State Transition Diagram
• Interaction Diagram
• Module Diagram
• Process Diagram

Coad–Yourdon Method

The Coad–Yourdon Method is an Object-Oriented Analysis (OOA) and Design (OOD) methodology developed by Peter Coad and Edward Yourdon.

Key Focus

• Identifying objects and classes
• Defining structures and relationships
• Separating analysis and design

Five Steps in OOA (Analysis Phase)

1.   Identify Classes & Objects

2.   Identify Structures (generalization, aggregation)

3.   Define Attributes

4.   Define Services (methods)

5.   Identify Subjects (group related classes)

Purpose:

To provide a simple, structured approach for analyzing and designing object-oriented systems.

 

Jacobson Method

 Definition

The Jacobson Method is an object-oriented software development methodology that focuses on use cases to capture system requirements.

It emphasizes:

User interaction with the system

Use-case driven development

Object-oriented analysis and design

Rumbaugh Method (OMT – Object Modeling Technique)

The Rumbaugh Method was developed by James Rumbaugh and is known as the Object Modeling Technique (OMT).

It is an object-oriented analysis and design methodology that focuses mainly on object modeling and data structure.

The Rumbaing Method (OMT) is an object-oriented software development approach that emphasizes object modelling, dynamic modelling, and functional modelling to design a system.

It uses three models:

1.   Object Model – Describes classes and relationships (static structure)

2.   Dynamic Model – Describes object behaviour (state changes)

3.   Functional Model – Describes data flow and processing

The Generic Components of an Object-Oriented (OO) Design Model is the fundamental elements used to design a system using object-oriented principles and components of an OO design model include:

·         Classes

·         Objects

·         Attributes

·         Methods

·         Relationships

·         Encapsulation

·         Abstraction

·         Polymorphism

·         Interfaces

 System Design Process

The System Design Process includes the following steps:

1.   Requirement Analysis – Understand and define user requirements.

2.   Feasibility Study – Check technical and economic feasibility.

3.   System Design – Design system architecture and modules.

4.   Implementation – Develop the system.

5.   Testing – Verify and validate the system.

6.   Deployment – Install and deliver the system.

7.   Maintenance – Provide updates and support.

Partitioning the Analysis Model

Partitioning the analysis model means dividing the system into smaller subsystems or modules to reduce complexity.

Types:

1.   Horizontal Partitioning – Divides system into functional modules.

2.   Vertical Partitioning – Divides system into layers (UI, logic, data).

Concurrency and Subsystem Allocation

Concurrency – Performing multiple tasks at the same time to improve system performance.

Subsystem Allocation – Assigning different modules or subsystems to specific hardware or system components.

Task Management Component

The Task Management Component is responsible for managing and controlling the execution of tasks in a system.

Functions:

• Creating and scheduling tasks
• Managing task priority
• Allocating resources
• Monitoring task execution
• Handling concurrency (multiple tasks at the same time)

Data Management Component

The Data Management Component is responsible for storing, organizing, retrieving, and maintaining data in a system.

Functions:

·         Data storage and retrieval

·         Database management

·         Data validation

·         Ensuring data security

·         Backup and recovery

Resource Management Component

The Resource Management Component is responsible for managing system resources efficiently.

Functions:

·         Allocating and deallocating resources

·         Managing memory and CPU usage

·         Handling devices and network resources

·         Monitoring resource performance

Inter-Subsystem Communication

  Inter-subsystem communication is the exchange of data and messages between different subsystems. It helps modules coordinate and work together smoothly.

 Object Design Process

The Object Design Process focuses on refining the analysis model into a detailed design ready for implementation.

Steps:

1.   Identify Classes and Objects – Define required classes.

2.   Define Attributes and Methods – Specify data and operations.

3.   Establish Relationships – Set inheritance, association, and aggregation.

4.   Design Interfaces – Define how objects interact.

5.Optimize Design – Improve performance and reduce complexity.

Assignment Question

1. What is OOD?
2. Explain Booch Method in details.
3. Explain  Coad–Yourdon Method in details
4. Explain   Jacobson Method in details.
5. Explain Rumbaugh Method in details.
6. List the Generic Components of an Object-Oriented.
7. What is System Design Process?
8. What is Concurrency and Subsystem Allocation?
9. What is Inter-subsystem communication?
10. Explain Object Design Process.
11. Explain Iterative Development and rational Unified Process (RUP).
12. What is Inception & Elaboration? 

 

 

 

SHARE

Milan Tomic

Hi. I’m Designer of Blog Magic. I’m CEO/Founder of ThemeXpose. I’m Creative Art Director, Web Designer, UI/UX Designer, Interaction Designer, Industrial Designer, Web Developer, Business Enthusiast, StartUp Enthusiast, Speaker, Writer and Photographer. Inspired to make things looks better.

• 
• 
• 
• 
•