Scribd
Upload
23 views10 pages

Order in Object-Oriented Analysis

The document provides an overview of Object Oriented Analysis and Design (OOAD), explaining its principles, methodologies, and the importance of modeling in software engineering. It discusses key concepts such as object-oriented approach, abstraction, hierarchy, and decomposition, highlighting their roles in managing complexity in software systems. Additionally, it emphasizes the significance of design in constructing systems that meet functional specifications and performance requirements.

Uploaded by

maneeshgopisetty
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
23 views10 pages

Order in Object-Oriented Analysis

The document provides an overview of Object Oriented Analysis and Design (OOAD), explaining its principles, methodologies, and the importance of modeling in software engineering. It discusses key concepts such as object-oriented approach, abstraction, hierarchy, and decomposition, highlighting their roles in managing complexity in software systems. Additionally, it emphasizes the significance of design in constructing systems that meet functional specifications and performance requirements.

Uploaded by

maneeshgopisetty
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

Unit-1

Introduction to OOAD:
OOAD stand for “Object Oriented Analysis and Design”. It is a software engineering
approach. It models a system as a group of interacting objects .
Object-oriented analysis and design (OOAD) is a technical approach for analyzing and
designing an application, system, or business by applying object-oriented programming

What is Object Oriented approach:


Object-orientation is what’s referred to as a programming paradigm. It’s not a
language itself but a set of concepts that is supported by many languages. If everything we
do in these languages is object-oriented, it means, we are oriented or focused around
objects.

What is Object-Oriented Analysis:


Grady Booch has defined OOA as, “Object-oriented analysis is a method of analysis that
examines requirements from the perspective of the classes and objects found in the
vocabulary of the problem domain”.

What is Design:
Grady Booch has defined object-oriented design as “a method of design encompassing the
process of object-oriented decomposition and a notation for depicting both logical and
physical as well as static and dynamic models of the system under design”.

What is an Object model?


•​ The object model identifies the classes in the system and their relationship, as well
as their attributes and operations. It represents the static structure of the system. The
object model is represented graphically by using diagram.
•​ The object model encompasses the principles of abstraction, encapsulation,
modularity, hierarchy, typing, concurrency, and persistence.
Following steps are performed in constructing an object model.
•​ Read carefully, the problem statement.
•​ Locate the object classes by underlining nouns.
•​ Remove unnecessary and incorrect classes.
•​ Prepare a data dictionary.
•​ Locate associations between object classes.
•​ Remove unnecessary and incorrect attributes.
•​ Use inheritance to share common structure.
•​ Remove unnecessary and incorrect associations.
•​ Locate attributes of the object classes.
Object oriented:
In object oriented contains classes and objects.
•​ Class: class is a collection of objects. A class contains the class name, attributes
and methods. A class is a blueprint of an object.
Object: an object is an instance of a class. An object is a real-time entity. It specifies the
state, behavior and identity.

The Structure of Complex systems:


​

Examples of structure of complex system

The Inherent Complexity of Software:


Attributes of Complex System:
Organized and Disorganized Complexity:

Feature Organized Complexity Disorganized Complexity


It is known complexity. It involves unknown difficulties.
Systems with many components whose Systems with many components,
Definition interactions follow a structured, interacting randomly or
rule-based and meaningful pattern, chaotically that is unpredictable.
Nature of Structured, interrelated, and often Random, probabilistic, lacks
System hierarchical structure
Predictable behavior due to logical
Predictability Hard to predict due to randomness
relationships
Requires detailed models (e.g., OO
Analysis Often studied using statistics and
models, flow charts, system
Method probability
architecture)
Example Object-oriented systems with Unorganized legacy code with no
(Software) interacting classes/modules clear architecture
Feature Organized Complexity Disorganized Complexity
Example A car engine, modern software, satellite Gas molecules in a container,
(Real-world) systems social media data without filters
Not suitable for traditional design;
Design Suitable for OOAD, structured design,
needs AI, ML, or data mining
Approach modularization
methods
Control & Difficult to control or change
Easier to control, maintain, and upgrade
Modifiability without full replacement

Bringing Order to Chaos:


One of the main goals of object-oriented analysis and design is to bring order to the
inherent chaos of software quality.
OOAD applies structured OO modelling techniques to transform chaos into an
organized, manageable system.

[Link]
Abstraction means to focus on the essential features of an element or object in OOP,
ignoring its extraneous or accidental properties. The essential features are relative to the
context in which the object is being used.
Grady Booch has defined abstraction as follows −
“An abstraction denotes the essential characteristics of an object that distinguish it
from all other kinds of objects and thus provide crisply defined conceptual boundaries,
relative to the perspective of the viewer.”
Example: Object: Student
Attributes: Sname, Sno, and Sgroup.
In the above example Student is an object whereas Sname, Sno, Sgroup are the
attributes for the student object are included whereas Sheight, Sweight are eliminated
because they are irrelevant according to educational institutions

Hierarchy:
It is the concept of inheritance. It defines a relationship among classes. It is
represented as a tree structure.
We define hierarchy as follows: “Hierarchy is a ranking or ordering of
abstractions”. The two most important hierarchies in a complex system are its class
structure (the “is a” hierarchy) and its object structure (the “part of” hierarchy).
inheritance denotes an “is a” relationship.
(Super Class: The class whose features are inherited is known as super class (or a
base class or a parent class).
Sub Class: The class that inherits the other class is known as sub class (or a derived
class, extended class, or child class). The subclass can add its own fields and methods in
addition to the superclass fields and methods.)
For example:
•​ a bear “is a” kind of mammal
•​ a house “is a” kind of tangible asset
•​ a quick sort “is a” particular kind of sorting algorithm.
Decomposition:
•​ Decomposition is important techniques for copying with complexity
based on the idea of divide and conquer.
•​ In dividing a problem into a sub problem the problem becomes less
complex and easier to overlook and to deal with.
•​ Repeatedly dividing a problem will eventually lead to sub problems that
are small enough so that they can be conquered.
•​ After all the sub problems have been conquered and solutions to them
have been found, the solutions need to be composed in order to obtain
the solution of the whole problem.
The history of computing has seen two forms of decomposition,
process-oriented (Algorithmic) and object-oriented decomposition.
Algorithmic Decomposition: In Algorithmic decomposition, each module in
the system denotes a major step in some overall process.

Another example for decomposition:


Object oriented decomposition:
Object-oriented decomposition is data- and behavior-driven (ideal for complex
and modular systems). Here decomposition is based on objects and not
algorithms. object-oriented decomposition for systems where data modeling
and abstraction are important.

Another example for processing payroll of class diagram:


Designing complex systems:

Engineering as a Science and an Art:


•​ Every engineering discipline involves elements of both science and art.
•​ The programming challenge is a large scale exercise in applied
abstraction and thus requires the abilities of the formal mathematician
blended with the attribute of the competent engineer.
•​ The role of the engineer as artist is particularly challenging when the task
is to design an entirely new system.
The meaning of Design:
The purpose of design is to construct a system that.
•​ Satisfies a given (perhaps) informal functional specification
•​ Conforms to limitations of the target medium
•​ Meets implicit or explicit requirements on performance and resource
usage
•​ Satisfies implicit or explicit design criteria on the form of the artifact
•​ Satisfies restrictions on the design process itself, such as its length or
cost, or the available for doing the design.
The Importance of Model Building:
•​ The buildings of models have a broad acceptance among all
engineering disciplines largely because model building appeals to the
principles of decomposition, abstraction and hierarchy.
•​ More than one kind of model is used on order to express all the
subtleties of a complex system
The Elements of Software design Methods:
Design of complex software system involves an
incremental and iterative process. Each method includes the following:
1. Notation: The language for expressing each model.
2. Process: The activities leading to the orderly construction of the system's
mode.
3. Tools: The artifacts that eliminate the medium of model building and enforce
rules about
the models themselves, so that errors and inconsistencies can be exposed.​
The models of Object Oriented Development:
•​ The models of object oriented analysis and design reflect the
importance of explicitly capturing both the class and object hierarchies
of the system under design.
•​ These models also over the spectrum of the important design decisions
that we must consider in developing a complex system and so
encourage us to craft implementations that embody the five attributes of
well-formed complex systems.

•​

Common questions

Powered by AI

Hierarchy in object-oriented design facilitates the organization and classification of system components through inheritance, which signifies an "is-a" relationship. This allows for the creation of a class structure that defines parent-child relationships, enabling code reusability and structural clarity. Hierarchy aids in system manageability by arranging classes and objects in a tree structure, allowing for modularization and easier maintenance. It supports the abstraction principle by providing clear layers of abstraction that simplify system complexity and promote scalability .

Process-oriented decomposition breaks a system into modules that represent major steps of an algorithm, which is suitable for problems that are purely procedural. In contrast, object-oriented decomposition is driven by data and behavior, focusing on objects rather than processes, making it ideal for complex, modular systems. The latter allows encapsulating data and behavior associated with objects, promoting reuse, scalability, and flexibility in handling stateful interactions between system components. It aligns with natural problem dimensions in complex systems, thus better handling their inherent intricacies .

Modularization is significant in object-oriented design as it involves dividing a system into discrete modules that encapsulate certain functionality, promoting reusability, scalability, and ease of maintenance. Each module represents a logical unit of a system, allowing developers to modify individual parts without affecting the entire system. This isolation of concerns simplifies debugging, testing, and updating processes, thus enhancing software reliability and longevity. Modularization aligns with OOAD's objectives to manage complexity through structured system architecture .

Decomposition enhances the handling of software complexity by breaking down large systems into manageable subproblems through a divide-and-conquer strategy. In both algorithmic and object-oriented decomposition, problems are repeatedly divided until they become small enough to be solved independently. Object-oriented decomposition is particularly effective in OOAD as it is data- and behavior-driven, focusing on objects instead of algorithms. This approach helps manage complexity by enabling developers to tackle smaller, more comprehensible parts before integrating them into a cohesive whole .

OOAD helps transform the inherent chaos in software development by applying structured object-oriented modeling techniques that turn disorderly elements into organized systems. It employs techniques like abstraction, hierarchy, and modularization, making complex systems easier to manage and understand. By providing clear frameworks for the interactions and relationships between objects and classes, OOAD enables systematic organization and enhances system predictability, thus creating a manageable and maintainable software structure .

Engineers play a dual role as scientists and artists by combining rigorous scientific principles with creative design to construct innovative systems. In OOAD, the scientific aspect involves applying formal methodologies and abstractions to model complex systems, ensuring functionality and efficiency. The artistic aspect requires intuition and creativity to design user-friendly and aesthetically pleasing interfaces or systems. This duality is crucial in OOAD, where the creation of a new system demands both technical precision and innovative design capabilities to meet both functional and non-functional requirements .

Control and modifiability are crucial in object-oriented systems as they determine the ease with which a system can be managed and updated. These aspects are enhanced through principles like encapsulation and modularization, which segment a system into comprehensible and manageable parts. This segmentation aids in isolating changes and minimizing their impact across the system. The resultant flexibility and adaptability in system management lead to higher software quality by enabling quicker responses to evolving requirements and reducing the potential for errors during maintenance .

Abstraction plays a crucial role in object-oriented analysis and design by allowing developers to focus on the essential characteristics of an object, distinct from its extraneous properties. This focus on essential features relative to the context results in clearly defined conceptual boundaries, which is necessary for efficient system development. By ignoring incidental details, abstraction enables simpler system models that are easier to manage and modify, thus facilitating the organization of complex systems into more understandable structures .

Organized complexity in software systems refers to components interacting in structured, rule-based, and predictable patterns, which makes them amenable to detailed modeling through object-oriented models, flow charts, and system architecture. These systems are easier to control, maintain, and upgrade. Disorganized complexity, on the other hand, involves components interacting randomly or chaotically in an unpredictable manner, making them challenging to manage without full replacement. Methods such as AI, ML, or data mining may be more suitable for dealing with disorganized complexity due to its unpredictability .

Model building is pivotal in the engineering design process as it helps represent complex systems in a structured and understandable manner. In OOAD, model building incorporates the principles of decomposition, abstraction, and hierarchy to capture both class and object hierarchies explicitly, facilitating efficient communication of design decisions. It serves as a medium for iterating on system designs, identifying errors, and ensuring the alignment of the developed system with its intended functionality, performance, and resource constraints .

You might also like