Object Oriented Analysis:
Object Oriented Analysis (OOA) is the first technical activity performed as part of object
oriented software engineering. OOA introduces new concepts to investigate a problem. It is
based in a set of basic principles, which are as follows-
1. The information domain is modeled.
2. Behavior is represented.
3. Function is described.
4. Data, functional, and behavioral models are divided to uncover greater detail.
5. Early models represent the essence of the problem, while later ones provide
implementation
Object Oriented Design :
An analysis model created using object oriented analysis is transformed by object oriented
design into a design model that works as a plan for software creation. OOD results in a design
having several different levels of modularity i.e., The major system components are partitioned
into subsystems (a system level “modular”), and data their manipulation operations are
encapsulated into objects (a modular form that is the building block of an Object oriented
system.).
In addition, OOD must specify some data organization of attributes and a procedural description
of each operation.
OOAD Models:
The Rumbaugh method:
The Rumbaugh methodology also known as OMT (Object Modeling Technique) is an approach
used to develop manageable object-oriented systems and host object oriented programming. The
purpose is to allow for class attributes, methods, inheritance, and association to be easily
expressed. OMT is used in the real world for software modeling and designing.
According to Rumbaugh, there are several main reasons to utilize this modeling approach. One is
to simulate entities before constructing them and another is to make communication with
customers easier. Additionally, it help to reduce complexity through visualization.
The Booch Method:
Booch's methodology has its primary strength in the object system design. Grady Booch has
included in his methodology a requirements analysis that is similar to a traditional requirements
analysis, as well as a domain analysis phase. Booch's object system design method has four parts,
the logical structure design where the class hierarchies are defined, the physical structure
diagram where the object methods are described. In addition, Booch defines the dynamics of
classes in a fashion very similar to the Rumbaugh method, as well as an analysis of the dynamics
of object instances, where he describes how an object may change state.
The Booch method is a method for object-oriented software development.
It is composed of an object modeling language an iterative object-oriented development
process, and a set of recommended practices
The method was authored by Grady Booch when he was working for Rational Software
(acquired by IBM), published in 1992 and revised in 1994.
It was widely used in software engineering for object-oriented analysis and design and
benefited from ample documentation and support tools.
The notation aspect of the Booch method was superseded by the Unified Modeling
Language (UML), which features graphical elements from the Booch method along with
elements from the object-modeling technique (OMT) and object-oriented software
engineering (OOSE).
The Coad-Yourdon method
Coad-Yourdon methodology has its primary strength in system analysis. Their methodology is
based on a technique called "SOSAS", which stands for the five steps that help make up the
analysis part of their methodology. The first step in system analysis is called "Subjects", which
are basically data flow diagrams for objects. The second step is called "Objects", where they
identify the object classes and the class hierarchies. The third step is called "Structures", where
they decompose structures into two types, classification structures and composition structures.
Classification structures handle the inheritance connection between related classes, while
composition structures handle all of the other connections among classes. The next step in
analysis is called "Attributes", and the final step is called "Services", where all of the behaviors
or methods for each class are identified.
Following analysis, Coad and Yourdon define four parts that make up the design part of their
methodology. The steps of system design are:
The problem domain component - This will define the classes that should be in the
problem domain.
The human interaction component - These steps defines the interface classes between
objects.
The task management component - This is where system-wide management classes are
identified.
The data management component - This design step identifies the classes needed for
database access methods.
The Shlaer-Mellor method
Shlaer-Mellor methodology has its primary strength in system design and is considered
somewhat weak on analysis. The Shlaer-Mellor methodology includes three models; the
information model, the state model, and the process model. The information model contains
objects, variables, and all the relationships between the objects, and is basically a data model for
the system. The state model records the different states of objects and changes that can occur
between the objects. The process model is really not much more than a traditional data flow
diagram.
Now that we have covered the basics of the object approach, let's take a look at how a real-world
object is created by using these techniques.
Jacobson Methodology :
The Jacobson methodology, also known as Object-Oriented Software Engineering (OOSE) or
even Objectory, is a method used to plan, design, and implement object-oriented software. The
method is broken down into five parts: a set of requirements, an analysis, a design, an
implementation, and a testing model. Uniquely, the methodology or OOSE utilizes use cases in
its design. We will go into more detail about these use cases and the five parts later on.
The Jacobson methodologies cover the entire life cycle and stress traceability between
the different phases both forward and backward. (example Object – Oriented Business
Engineering (OOBE), Object Oriented Software Engineering (OOSE) and Objectory)
This traceability enables reuse of analysis and design work, possibly much bigger factors
in the reduction development time then reuse of code.
At the heart of their methodologies is the use-case concept, which evolved with
Objectory (Object Factory for Software Development)
References:
1
. http://www.dba-oracle.com/t_object_oriented_analysis_models.htm
2
. https://www.geeksforgeeks.org/object-oriented-analysis-and-design
3
. https://iq.opengenus.org/rumbaugh-booch-and-jacobson-methodologies
