Scribd
Upload
4 views3 pages

Unit 3

Uploaded by

Vandana Bharti
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
4 views3 pages

Unit 3

Uploaded by

Vandana Bharti
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 3

UNIT – 03 OBJECT ORIENTED ANALYSIS

Object-Oriented Analysis (OOA)

Object-Oriented Analysis (OOA) is the process of analyzing and modeling a


system by visualizing it as a group of interacting objects. Each object represents an
entity with attributes and behaviors. OOA focuses on understanding the problem
domain and identifying the key entities (objects) and their relationships.

Key Aspects of Object-Oriented Design (OOD)

1. Object-Oriented Design (OOD):


OOD is the step after OOA where the system's objects are designed in detail.
This includes specifying the attributes, behaviors (methods), and interactions
among objects to satisfy the system's requirements. The focus is on the design of
classes, their hierarchies, and relationships, providing a blueprint for system
implementation.

2. **Object Design**:
In Object Design, classes and objects are defined with more precision. The
attributes (fields) and operations (methods) for each class are clearly specified. The
goal is to create reusable and extendable components. At this stage, the design
ensures that object interaction flows efficiently and meets performance and
functional requirements.

3. **Combining Three Models**:


To create a cohesive design, three essential models are typically combined:
- **Object Model**: Represents the structure of objects and their relationships
(class diagrams).
- **Dynamic Model**: Represents the interactions between objects over time
(sequence diagrams, state machines).
- **Functional Model**: Describes what the system must do (use cases, activity
diagrams).
The combination of these models ensures that the system's static structure,
dynamic behavior, and functional requirements are properly aligned.

4. **Designing Algorithms**:
Algorithms are designed to define how the system’s functionality will be
implemented at a lower level. In object-oriented design, algorithms are tightly
coupled with objects and classes. This step focuses on creating efficient algorithms
for key functionalities that need to be executed by the objects.

5. **Design Optimization**:
Design optimization refines the design by improving its efficiency, modularity,
and performance. This could involve reducing complexity, improving data
structures, minimizing resource consumption, and enhancing maintainability. For
example, adjusting class hierarchies, reusing objects, and optimizing
communication between objects.

6. **Implementation of Control**:
Implementation of control involves designing how the system will control the
flow of operations across different objects and components. This includes defining
control logic for object interactions, event handling, state transitions, and error
handling. This is particularly critical in real-time systems or systems with complex
workflows.

7. **Adjustment of Inheritance**:
Inheritance is a key feature of object-oriented design that allows classes to inherit
properties and behaviors from parent classes. Adjusting inheritance involves
ensuring that class hierarchies are designed properly, avoiding unnecessary
inheritance or excessive coupling. It also includes fine-tuning inheritance to enable
code reuse, extensibility, and proper abstraction.

8. **Object Representation**:
Object representation refers to how objects are implemented in the system,
including their internal data structures, memory management, and access methods.
This step focuses on efficiently representing objects in a way that optimizes
performance while maintaining the system's flexibility.

9. **Physical Packaging**:
Physical packaging is about organizing the software components (objects,
classes, libraries) into physical modules or packages. This process ensures that
related components are grouped together and can be deployed, reused, or
maintained easily. The packaging also affects how different components interact,
both at compile-time and run-time.

10. **Documenting Design Considerations**:


Documenting design considerations involves capturing the rationale behind
design decisions, trade-offs, constraints, and assumptions. This documentation is
essential for future maintenance and understanding the reasoning behind the
system’s design. It may include design patterns used, alternative approaches
considered, and guidelines for extending or modifying the design in the future.

### Conclusion
Object-Oriented Analysis and Design (OOAD) is a structured approach to software
development, where objects are central to the design. By following the steps
outlined above, a system is designed to be modular, maintainable, and scalable,
ensuring efficient implementation and future extensibility.

You might also like