7/16/24, 12:44 PM Object Oriented Analysis and Design: The Object Model

More Create Blog Sign In

The Object Model

Foundations of the Object Model :

Structured design methods evolved to guide developers who were trying to build complex
systems using algorithms as their fundamental building blocks. Similarly, object-oriented design
methods have evolved to help developers exploit the expressive power of object-based and
object-oriented programming languages, using the class and object as basic building blocks.

However, there are limits to the amount of complexity we can handle using only algorithmic
decomposition; thus we must turn to object-oriented decomposition. Furthermore, if we try to
use languages such as C++ and Java as if they were only traditional, algorithmically oriented
languages, we not only miss the power available to us, but we usually end up worse off than if
we had used an older language such as C or Pascal.

Object-Oriented Programming –

“Object-oriented programming is a method of implementation in which programs are organized

as cooperative collections of objects, each of which represents an instance of some class, and
whose classes are all members of a hierarchy of classes united via inheritance relationships.”

There are three important parts to this definition:

(1) Object-oriented programming uses objects, not algorithms, as its fundamental logical
building blocks
(2) each object is an instance of some class
(3) classes may be related to one another via inheritance relationships (the “is a” hierarchy).

A program may appear to be object-oriented, but if any of these elements is missing, it is not an
object-oriented program. Specifically, programming without inheritance is distinctly not object-
oriented; that would merely be programming with abstract data types.If a language does not
provide direct support for inheritance, then it is not object-oriented. Cardelli and Wegner Pages
distinguish such languages by calling them object-based rather than object-oriented. Under this
definition, Smalltalk, Object Pascal, C++, Eiffel, CLOS, C#, and Java are all object-oriented, and Home

Ada83 is object-based The Object Model

Classes and Objects
UML Notation
Object-Oriented Design – Process
“Object-oriented design is 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
Followers
dynamic models of the system under design.”
Followers (3)
There are two important parts to this definition: object-oriented design

(1) leads to an object-oriented decomposition and

Follow
(2) uses different notations to express different models of the logical (class and object structure)
and physical (module and process architecture) design of a system, in addition to the static and
dynamic aspects of the system. Blog Archive

▼
▼ 2010 (1)
The support for object-oriented decomposition is what makes object-oriented design quite
different from structured design: The former uses class and object abstractions to logically ▼
▼ December (1)
structure systems, and the latter uses algorithmic abstractions. Object Oriented Analysis and
Design

Object-Oriented Analysis –
“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.”

https://masters-ooad.blogspot.com/p/object-model.html 1/6
7/16/24, 12:44 PM Object Oriented Analysis and Design: The Object Model
How are OOA, OOD, and OOP related? Basically, the products of object-oriented analysis
serve as the models from which we may start an object-oriented design;the products of object-
oriented design can then be used as blueprints for completely implementing a system using
object-oriented programming methods.

Elements of the Object Model :

There are five main kinds of programming styles, listed here with the kinds of abstractions they
employ:
1.Procedure-oriented Algorithms
2.Object-oriented Classes and objects
3.Logic-oriented Goals, often expressed in a predicate calculus
4.Rule-oriented If–then rules
5.Constraint-oriented Invariant relationships

There is no single programming style that is best for all kinds of applications. For example, rule-
oriented programming would be best suited for the design of a knowledge base, and procedure-
oriented programming would be best for the design of computation-intense operations. From
our experience, the object-oriented style is best suited to the broadest set of applications;
indeed, this programming paradigm often serves as the architectural framework in which we
employ other paradigms.

Each of these styles of programming is based on its own conceptual framework. Each requires
a different mindset, a different way of thinking about the problem. For all things object-oriented,
the conceptual framework is the object model.

There are four major elements of this model:

1.Abstraction
2.Encapsulation
3.Modularity
4.Hierarchy

There are three minor elements of the object model:

1.Typing
2.Concurrency
3.Persistence

The Meaning of Abstraction –

“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”
An abstraction focuses on the outside view of an object and so serves to separate an object’s
essential behavior from its implementation
“Abstraction focuses on the essential characteristics of some object, relative to the perspective
of the viewer”

All abstractions have static as well as dynamic properties. For example, a file object takes up a
certain amount of space on a particular memory device; it has a name, and it has contents.
These are all static properties. The value of each of these properties is dynamic, relative to the
lifetime of the object: A file object may grow or shrink in size, its name may change, its contents
may change.In procedure-oriented style of programming, the activity that changes the dynamic
value of objects is the central part of all programs; things happen when subprograms are called
and statements are executed. In a rule-oriented style of programming, things happen when new
events cause rules to fire, which in turn may trigger other rules, and so on. In an object-oriented
style of programming, things happen whenever we operate on an object (i.e., when we send a
message to an object). Thus, invoking an operation on an object elicits some reaction from the
object.

Example
A client of this abstraction may invoke an operation to establish a critical range of temperatures.
It is then the responsibility of the sensor to report whenever the temperature at its location drops
below or rises above the given set point. When the function is invoked, the sensor provides its
location and the current temperature, so that the client has sufficient information to respond to
the condition.

“Objects collaborate with other objects to achieve some behavior.”

“No object stands alone; every object collaborates with other objects to achieve some
behavior.1 Our design decisions about how these objects cooperate with one another define the
boundaries of each abstraction and thus the responsibilities and protocol of each object.”

https://masters-ooad.blogspot.com/p/object-model.html 2/6
7/16/24, 12:44 PM Object Oriented Analysis and Design: The Object Model

The Meaning of Encapsulation

“Encapsulation hides the details of the implementation of an object”
Abstraction and encapsulation are complementary concepts: Abstraction focuses on the
observable behavior of an object, whereas encapsulation focuses on the implementation that
gives rise to this behavior. Encapsulation is most often achieved through information hiding (not
just data hiding), which is the process of hiding all the secrets of an object that do not contribute
to its essential characteristics; typically, the structure of an object is hidden, as well as the
implementation of its methods.

“For abstraction to work, implementations must be encapsulated” [53]. In practice, this means
that each class must have two parts: an interface and an implementation. The interface of a
class captures only its outside view, encompassing our abstraction of the behavior common to
all instances of the class. The implementation of a class comprises the representation of the
abstraction as well as the mechanisms that achieve the desired behavior. The interface of a
class is the one place where we assert all of the assumptions that a client may make about any
instances of the class; the implementation encapsulates details about which no client may make
assumptions.
“Encapsulation is the process of compartmentalizing the elements of an abstraction that
constitute its structure and behavior; encapsulation serves to separate the contractual interface
of an abstraction and its implementation.”

Examples of Encapsulation
The client would not see any change at all as the client sees only the Heater interface. This is
the key point of encapsulation. In fact, the client should not care what the implementation is, as
long as it receives the service it needs from the Heater.

The Meaning of Modularity

““The act of partitioning a program into individual components can reduce its complexity to
some degree. . Modularization consists of dividing a program into modules which can be
compiled separately, but which have connections with other modules.”
For anything but the most trivial software, a better solution is to group logically related classes
and objects in the same module and to expose only those elements that other modules
absolutely must see. This kind of modularization is a good thing,
“Modularity is the property of a system that has been decomposed into a set of cohesive and
loosely coupled modules.”

In traditional structured design, modularization is primarily concerned with the meaningful

grouping of subprograms, using the criteria of coupling and cohesion. In object-oriented design,
the problem is subtly different: The task is to decide where to physically package the classes
and objects, which are distinctly different from subprograms.
Java has packages that contain classes. In many other languages, including Object Pascal,
C++, and Ada, the module is a separate language construct and therefore warrants a separate
set of design decisions. In these languages, classes and objects form the logical structure of a
system; we place these abstractions in modules to produce the system’s physical architecture.
Especially for larger applications, in which we may have many hundreds of classes, the use of
modules is essential to help manage complexity.

The Meaning of Hierarchy

Abstraction is a good thing, but in all except the most trivial applications, we may find many
more different abstractions than we can comprehend at one time. Encapsulation helps manage
this complexity by hiding the inside view of our abstractions.
Modularity helps also, by giving us a way to cluster logically related abstractions. Still, this is not
enough. A set of abstractions often forms a hierarchy, and by identifying these hierarchies in our
design, we greatly simplify our understanding of the problem.

“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).”

Examples of Hierarchy: Single Inheritance

Inheritance defines a relationship among classes, wherein one class shares the structure or
behavior defined in one or more classes (denoting single inheritance and multiple inheritance,
respectively). Inheritance thus represents a hierarchy of abstractions, in which a subclass
inherits from one or more superclasses.
Semantically, inheritance denotes an “is a” relationship. For example, a bear “is a” kind of
mammal, a house “is a” kind of tangible asset, and a quick sort “is a” particular kind of sorting
algorithm. Inheritance thus implies a generalization/specialization hierarchy, wherein a subclass
specializes the more general structure or behavior of its superclasses.

Different programming languages trade off support for encapsulation and inheritance in different
ways. C++ and Java offer great flexibility. Specifically, the interface of a class may have three
parts: private parts, which declare members that are accessible only to the class itself;
protected parts, which declare members that are accessible only to the class and its
subclasses; and public parts, which are accessible to all clients.

Examples of Hierarchy: Multiple Inheritance

For certain abstractions, it is useful to provide inheritance from multiple superclasses For

https://masters-ooad.blogspot.com/p/object-model.html 3/6
7/16/24, 12:44 PM Object Oriented Analysis and Design: The Object Model
example, we can define a Rose class (see Figure 2–10) that inherits from both Plant and
FlowerMixin. Instances of the subclass Rose thus include the structure and behavior from the
class Plant together with the structure and behavior from the class FlowerMixin.

Multiple inheritance is conceptually straightforward, but it does introduce some practical

complexities for programming languages. Languages must address two issues: clashes among
names from different superclasses and repeated inheritance. Clashes will occur when two or
more superclasses provide a field or operation with the same name or signature as a peer
superclass.Repeated inheritance occurs when two or more peer superclasses share a common
Superclass. In such a situation, the inheritance lattice will be diamond-shaped, so the question
arises, does the leaf class (i.e., subclass) have one copy or multiple copies of the structure of
the shared superclass? (See Figure 2–13.)

such as C++, permit the programmer to decide. In C++, virtual base classes are used to denote
a sharing of repeated structures, whereas nonvirtual base classes result in duplicate copies
appearing in the subclass.

Examples of Hierarchy: Aggregation

Whereas these “is a” hierarchies denote generalization/specialization relationships, “part of”
hierarchies describe aggregation relationships.
For example, consider the abstraction of a garden. We can contend that a garden consists of a
collection of plants together with a growing plan. In other words, plants are “part of” the garden,
and the growing plan is “part of” the garden. This “part of” relationship is known as aggregation
In terms of its “is a” hierarchy, a high-level abstraction is generalized, and a low-level
abstraction is specialized. Therefore, we say that a Flower class is at a higher level of
abstraction than a Plant class. In terms of its “part of” hierarchy, a class is at a higher level of
abstraction than any of the classes that make up its implementation. Thus, the class Garden is
at a higher level of abstraction than the type Plant, on which it builds

The Meaning of Typing

Typing lets us express our abstractions so that the programming language in which we
implement them can be made to enforce design decisions.A given programming language may
be strongly typed, weakly typed, or even untyped, yet still be called object-oriented
Practically, strong typing introduces semantic dependencies such that even small changes in
the interface of a base class require recompilation of all subclasses.

There are two general solutions to these problems. First, we could use a type-safe container
class that manipulates only objects of a specific class. This approach addresses the first
problem, wherein objects of different types are incorrectly mingled. Second, we could use some
form of runtime type identification; this addresses the second problem of knowing what kind of
object you happen to be examining at the moment.
There are a number of important benefits to be derived from using strongly typed languages:
- Without type checking, a program in most languages can ‘crash’ in mysterious ways at
runtime.
- In most systems, the edit-compile-debug cycle is so tedious that early error detection is
indispensable.
- Type declarations help to document programs.
- Most compilers can generate more efficient object code if types are declared.

Examples of Typing: Static and Dynamic Typing

The concepts of strong and weak typing and static and dynamic typing are entirely different.
Strong and weak typing refers to type consistency, whereas static and dynamic typing refers to
the time when names are bound to types. Static typing (also known as static binding or early
binding) means that the types of all variables and expressions are fixed at the time of
compilation; dynamic typing (also known as late binding) means that the types of all variables

https://masters-ooad.blogspot.com/p/object-model.html 4/6
7/16/24, 12:44 PM Object Oriented Analysis and Design: The Object Model
and expressions are not known until runtime. A language may be both strongly and statically
typed (Ada), strongly typed yet supportive of dynamic typing (C++, Java)

The Meaning of Concurrency

“Concurrency allows different objects to act at the same time.”
For certain kinds of problems, an automated system may have to handle many different events
simultaneously. Other problems may involve so much computation that they exceed the
capacity of any single processor. Every program has at least one thread of control, but a system
involving concurrency may have many such threads: some that are transitory and others that
last the entire lifetime of the system’s execution.
Systems executing across multiple CPUs allow for truly concurrent threads of control, whereas
systems running on a single CPU can only achieve the illusion of concurrent threads of control,
usually by means of some time-slicing algorithm.

A heavy-weight process is one that is typically independently managed by the target operating
system and so encompasses its own address space. A lightweight process usually lives within a
single operating system process along with other light-weight processes, which share the same
address space. Communication among heavyweight processes is generally expensive,
involving some form of interpro-cess communication; communication among lightweight
processes is less expensive and often involves shared data.
Building a large piece of software is hard enough; designing one that encompasses multiple
threads of control is much harder because one must worry about such issues as deadlock,
livelock, starvation, mutual exclusion, and race conditions.

Examples of Concurrency
In general, there are three approaches to concurrency in object-oriented design.
First, concurrency is an intrinsic feature of certain programming languages, which provide
mechanisms for concurrency and synchronization.
Second, we may use a class library that implements some form of lightweight processes.
Naturally, the implementation of this kind is highly platform-dependent, although the interface to
the library may be relatively portable
Third, we may use interrupts to give us the illusion of concurrency. Of course, this requires that
we have knowledge of certain low-level hardware details. For example, in our implementation of
the class ActiveTemperatureSensor, we might have a hardware timer that periodically interrupts
the application, during which time all such sensors read the current temperature and then
invoke their callback function as necessary.

The Meaning of Persistence

An object in software takes up some amount of space and exists for a particular amount of time.
Persistence saves the state and class of an object across time or space.
spectrum of object persistence encompasses the following:
- Transient results in expression evaluation
- Local variables in procedure activations
- Own variables [as in ALGOL 60], global variables, and heap items whose extent is different
from their scope
- Data that exists between executions of a program
- Data that exists between various versions of a program
- Data that outlives the program [79]

Introducing the concept of persistence to the object model gives rise to object-oriented
databases. In practice, such databases build on proven technology, such as sequential,
indexed, hierarchi-cal, network, or relational database models, but then offer to the programmer
the abstraction of an object-oriented interface, through which database queries and other
operations are completed in terms of objects whose lifetimes transcend the lifetime of an
individual program. This unification vastly simplifies the development of certain kinds of
applications. In particular, it allows us to apply the same design methods to the database and
nondatabase segments of an application.

Some object-oriented programming languages provide direct support for persistence. Java
provides Enterprise Java Beans (EJBs) and Java Data Objects.

To summarize, we define persistence as follows:

Persistence is the property of an object through which its existence transcends time (i.e., the
object continues to exist after its creator ceases to exist) and/or space (i.e., the object’s location
moves from the address space in which it was created).

Benefits of the Object Model

First, the use of the object model helps us to exploit the expressive power of object-based and
object-oriented programming languages
Second, the use of the object model encourages the reuse not only of software but of entire
designs, leading to the creation of reusable application frameworks
Third, the use of the object model produces systems that are built on stable intermediate forms,
which are more resilient to change.

Open Issues
To effectively apply the elements of the object model, we must next address several open
issues.

https://masters-ooad.blogspot.com/p/object-model.html 5/6
7/16/24, 12:44 PM Object Oriented Analysis and Design: The Object Model
- What exactly are classes and objects?
- How does one properly identify the classes and objects that are relevant to a particular
application?
- What is a suitable notation for expressing the design of an object-oriented system?
- What process can lead us to a well-structured object-oriented system?
- What are the management implications of using object-oriented design?

Summary
The maturation of software engineering has led to the development of object-oriented analysis,
design, and programming methods, all of which address the issues of programming-in-the-
large.
- There are several different programming paradigms: procedure-oriented, object-oriented,
logic-oriented, rule-oriented, and constraint-oriented.
- 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.
- Encapsulation is the process of compartmentalizing the elements of an abstraction that
constitute its structure and behavior; encapsulation serves to separate the contractual interface
of an abstraction and its implementation.
- Modularity is the property of a system that has been decomposed into a set of cohesive and
loosely coupled modules.
- Hierarchy is a ranking or ordering of abstractions.
- Typing is the enforcement of the class of an object, such that objects of different types may not
be interchanged or, at the most, may be interchanged only in very restricted ways
- Concurrency is the property that distinguishes an active object from one that is not active.
- Persistence is the property of an object through which its existence transcends time and/or
space.

Home

Subscribe to: Posts (Atom)

Simple theme. Powered by Blogger.

https://masters-ooad.blogspot.com/p/object-model.html 6/6