Course Code : MCS-032

Course Title : Object Oriented Analysis and Design

Assignment Number : MCA(3)/032/Assign/09
Maximum Marks : 100
Weightage : 25%
Last Dates for Submission : 15th April, 2009 (For January Session)
15th October, 2009 (For July Session)

There are eight questions in this assignment which carries 80 marks. Rest 20
marks are for viva-voce. Answer all the questions. Please go through the
guidelines regarding assignments given in the Program Guide for the format
of presentation.

Question 1:

What is OOAD? Explain advantages of OOAD. (10 Marks)

ANSWER:Object-oriented analysis and design (OOAD) is a software

engineering approach that models a system as a group of interacting objects.
Each object represents some entity of interest in the system being modeled,
and is characterised by its class, its state (data elements), and its behavior.
Various models can be created to show the static structure, dynamic
behavior, and run-time deployment of these collaborating objects. There are
a number of different notations for representing these models, such as the
Unified Modeling Language (UML).

Object-oriented analysis (OOA) applies object-modeling techniques to analyze

the functional requirements for a system. Object-oriented design (OOD)
elaborates the analysis models to produce implementation specifications.
OOA focuses on what the system does, OOD on how the system does it.

Object-oriented analysis

Object-oriented analysis (OOA) looks at the problem domain, with the aim of
producing a conceptual model of the information that exists in the area being
analyzed. Analysis models do not consider any implementation constraints
that might exist, such as concurrency, distribution, persistence, or how the
system is to be built. Implementation constraints are dealt with during object-
oriented design (OOD). Analysis is done before the Design[citation needed].

The sources for the analysis can be a written requirements statement, a

formal vision document, interviews with stakeholders or other interested
parties. A system may be divided into multiple domains, representing
different business, technological, or other areas of interest, each of which are
analyzed separately.
The result of object-oriented analysis is a description of what the system is
functionally required to do, in the form of a conceptual model. That will
typically be presented as a set of use cases, one or more UML class diagrams,
and a number of interaction diagrams. It may also include some kind of user
interface mock-up.

Object-oriented design

Object-oriented design (OOD) transforms the conceptual model produced in

object-oriented analysis to take account of the constraints imposed by the
chosen architecture and any non-functional constraints, such as transaction
throughput, response time, run-time platform, development environment, or
programming language.

The concepts in the analysis model are mapped onto implementation classes
and interfaces. The result is a model of the solution domain, a detailed
description of how the system is to be built.

Question 2:

Explain characteristics of an Object Oriented Systems. (10 Marks)

ANSWER:An object-oriented system is composed of objects. The behavior of

the system results from the collaboration of those objects. Collaboration
between objects involves them sending messages to each other. Sending a
message differs from calling a function in that when a target object receives a
message, it itself decides what function to carry out to service that message.
The same message may be implemented by many different functions, the
one selected depending on the state of the target object.
The implementation of "message sending" varies depending on the
architecture of the system being modeled, and the location of the objects
being communicated with.

Characteristics of an Object Oriented Systems are as follows :-

Information hiding:-Information hiding in computer science is the principle of

hiding of design decisions in a computer program that are most likely to
change, thus protecting other parts of the program from change if the design
decision is changed. The protection involves providing a stable interface
which shields the remainder of the program from the implementation (the
details that are most likely to change).

Data abstraction:-In object-oriented programming theory, abstraction is the

facility to define objects that represent abstract "actors" that can perform
work, report on and change their state, and "communicate" with other
objects in the system. The term encapsulation refers to the hiding of state
details, but extending the concept of data type from earlier programming
languages to associate behavior most strongly with the data, and
standardizing the way that different data types interact, is the beginning of
abstraction. When abstraction proceeds into the operations defined, enabling
objects of different types to be substituted, it is called polymorphism. When it
proceeds in the opposite direction, inside the types or classes, structuring
them to simplify a complex set of relationships, it is called delegation or
inheritance.
Various object-oriented programming languages offer similar facilities for
abstraction, all to support a general strategy of polymorphism in object-
oriented programming, which includes the substitution of one type for
another in the same or similar role.

Encapsulation:-Encapsulation is the hiding of the internal mechanisms and

data structures of a software component behind a defined interface, in such a
way that users of the component (other pieces of software) only need to
know what the component does, and cannot make themselves dependent on
the details of how it does it. The purpose is to achieve potential for change:
the internal mechanisms of the component can be improved without impact
on other components, or the component can be replaced with a different one
that supports the same public interface.Encapsulation also protects the
integrity of the component, by preventing users from setting the internal data
of the component into an invalid or inconsistent state.Another benefit of
encapsulation is that it reduces system complexity and thus increases
robustness, by limiting the interdependencies between software components.
The concept of encapsulation is most commonly associated with object-
oriented programming, where the interface to an object is defined by its
public methods, while its internal state is represented by private data.
However, the idea is more general than this: for example, a relational
database is encapsulated in the sense that its only public interface is the SQL
language, which hides all the internal machinery and data structures of the
database management system. As such, encapsulation is a core principle of
good software architecture, at every level of granularity.
Encapsulating software behind an interface allows the construction of objects
that mimic the behavior and interactions of objects in the real world. For
example, road traffic can be simulated by creating objects that mimic the
behavior of real vehicles and road junctions. This idea is most prominent in
simulation and virtual reality software (for example, games), but it is also
important in other fields such as network modeling and computer-aided
design.

Modularity:-Modular programming is a software design technique that

increases the extent to which software is composed from separate parts,
called modules. Conceptually, modules represent a separation of concerns,
and improve maintainability by enforcing logical boundaries between
components. Modules are typically incorporated into the program through
interfaces. A module interface expresses the elements that are provided and
required by the module. The elements defined in the interface are visible to
other modules. The implementation contains the working code that
corresponds to the elements declared in the interface.

Polymorphism:-The primary usage of polymorphism in industry (object-

oriented programming theory) is the ability of objects belonging to different
types to respond to method, field, or property calls of the same name, each
one according to an appropriate type-specific behavior. The programmer (and
the program) does not have to know the exact type of the object in advance,
and so the exact behavior is determined at run time (this is called late
binding or dynamic binding). and

Inheritance:-In object-oriented programming, inheritance is a way to form

new classes (instances of which are called objects) using classes that have
already been defined. The inheritance concept was invented in 1967 for
Simula.The new classes, known as derived classes, take over (or inherit)
attributes and behavior of the pre-existing classes, which are referred to as
base classes (or ancestor classes). It is intended to help reuse existing code
with little or no modification.An advantage of inheritance is that modules with
sufficiently similar interfaces can share a lot of code, reducing the complexity
of the program.

Question 3:

What is Inheritances? Explain with an example, how Inheritance is shown in

class diagram. (10 Marks)

ANSWER:In object-oriented programming, inheritance is a way to form new

classes (instances of which are called objects) using classes that have already
been defined. The inheritance concept was invented in 1967 for Simula.
The new classes, known as derived classes, take over (or inherit) attributes
and behavior of the pre-existing classes, which are referred to as base classes
(or ancestor classes). It is intended to help reuse existing code with little or
no modification.
Inheritance provides the support for representation by categorization in
computer languages. Categorization is a powerful mechanism number of
information processing, crucial to human learning by means of generalization
(what is known about specific entities is applied to a wider group given a
belongs relation can be established) and cognitive economy (less information
needs to be stored about each specific entity, only its particularities).
Inheritance is also sometimes called generalization, because the is-a
relationships represent a hierarchy between classes of objects. For instance,
a "fruit" is a generalization of "apple", "orange", "mango" and many others.
One can consider fruit to be an abstraction of apple, orange, etc. Conversely,
since apples are fruit (i.e., an apple is-a fruit), apples may naturally inherit all
the properties common to all fruit, such as being a fleshy container for the
seed of a plant.
An advantage of inheritance is that modules with sufficiently similar
interfaces can share a lot of code, reducing the complexity of the program.
Inheritance therefore has another view, a dual, called polymorphism, which
describes many pieces of code being controlled by shared control code.
Inheritance is typically accomplished either by overriding (replacing) one or
more methods exposed by ancestor, or by adding new methods to those
exposed by an ancestor.
Complex inheritance, or inheritance used within a design that is not
sufficiently mature, may lead to the Yo-yo problem.

Question 4:
What is an object? Critically explain “Object Identification is one of the major
challenges in OOAD “.
(10 Marks)
ANSWER:In object-oriented programming (OOP), an instance of a program
(i.e. a program running in a computer) is treated as a dynamic set of
interacting objects. Objects in OOP extend the more general notion of objects
described above to include a very specific kind of typing, which among other
things allows for:

1. data members that represent the data associated with the object.
2. methods that access the data members in predefined ways.

In the case of most objects, the data members can only be accessed through
the methods, making it easy to guarantee that the data will always remain in
a well-defined state (class invariants will be enforced). Some languages do
not make distinctions between data members and methods.

In almost all object-oriented programming languages, a dot(.) operator is

used to call a particular method/function of an object. For example, consider
an arithmetic class named Arith_Class. This class contains functions like
add(), subtract(), multiply() and divide(), that process results for two numbers
sent to them. This class could be used to find the product of 78 and 69 by
first of all creating an object of the class and then invoking its multiply
method, as follows:

1 int result = 0; // Initialization

2 arith_Obj1 = new Arith_Class(); // Creating a new instance of Arith_Class
3 result = arith_Obj1.multiply(78,69); // Product of 78 and 69 stored in result
variable

In a language where each object is created from a class, an object is called an

instance of that class. If each object has a type, two objects with the same
class would have the same datatype. Creating an instance of a class is
sometimes referred to as instantiating the class.

A real-world example of an object would be "my dog", which is an instance of

a type (a class) called "dog", which is a subclass of a class "animal". In the
case of a polymorphic object, some details of its type can be selectively
ignored, for example a "dog" object could be used by a function looking for
an "animal". So could a "cat", because it too belongs to the class of "animal".
While being accessed as an "animal", some member attributes of a "dog" or
"cat" would remain unavailable, such as the "tail" attribute, because not all
animals have tails.

A ghost is an object that is unreferenced in a program, and can therefore

serve no purpose. In a garbage-collected language, the garbage collector
would mark the memory occupied by the object as free, although it would still
contain the object's data until it was overwritten.

Three properties characterize objects:

1. Identity: the property of an object that distinguishes it from other objects

2. State: describes the data stored in the object
3. Behavior: describes the methods in the object's interface by which the
object can be used

Some terms for specialized kinds of objects include:

* Singleton object: An object that is the only instance of its class during the
lifetime of the program.
* Functor (function object): an object with a single method (in C++, this
method would be the function operator, "operator()") that acts much like a
function (like a C/C++ pointer to a function).
* Immutable object: an object set up with a fixed state at creation time and
which does not vary afterward.
* First-class object: an object that can be used without restriction.
* Container: an object that can contain other objects.
* Factory object: an object whose purpose is to create other objects.
* Metaobject: an object from which other objects can be created (Compare
with class, which is not necessarily an object)
* Prototype: a specialized metaobject from which other objects can be
created by copying
* God object: an object that knows too much or does too much. The God
object is an example of an anti-pattern.
* Antiobjects: a computational metaphor useful to conceptualize and solve
hard problems often with massively parallel approaches by swapping
computational foreground and background.....
Filter object

The purpose of object modeling is to describe objects. For example, Joe

Smith, Simplex company, and the top window are objects. An object is simply
something that makes sense in an application context. Objects serves two
purposes: they promote understanding of the real world and provide a
practical basis for computer implementation. Decomposition fo a problem
into objects depends on judgments and the nature of the problem. There is
no one correct representation.

All objects have identity and are distinguishable. Two apples with the same
color, shape and texture are still individual apples; a person can eat one and
then eat the other.
An object class describes group with similar properties, common behavior,
common relationships to other objects, and common semantics, company,
animal, process, and window are all object classes. Ach person has an age,
IQ, and may work at a job. Ac process has an owner, priority, and list of
required resources. Objects and object classes often appear as nouns in
problem description.

The object in class share a common semantic purpose, above and beyond the
requirement of common attributes and behavior. Each object knows its class.

Identifying Objects (and Class)

Identify the nouns( objects) in the problem description.
Identify more objects in your developing problem solution.
From these objects, determine what new types (classes) you need.
Example: Black Jack Program
Cards
A deck
A dealer
Player(s)
Sample Design Questions:
Are the dealer and player instances of the same class? i.e., objects of the
same type?
Should there be a separate Hand class?

Question 5:
What is a state diagram? Explain the characteristics of the system that can
be identified by examination of the state diagram of that System. (10 Marks)

Ans. State diagrams (also called State Chart diagram) are used to help the
developer better understand any complex/unusual functionalities or business
flows of specialized areas of the system. In short, State diagrams depict the
dynamic behavior of the entire system, or a sub-system, or even a single
object in a system. This is done with help of Behavioral elements.

The characteristics of the system that identified by examination of the state

diagram of that System are given below:

Initial state: This shows the starting point or first activity of the flow. Denoted
by a solid circle. This is also called as a “pseudo state,” where the state has
no variables describing it further and no activities.
State: Represents the state of object at an instant of time. In a state diagram,
there will be multiple of such symbols, one for each state of the Object we are
discussing. Denoted by a rectangle with rounded corners and compartments
(such as a class with rounded corners to denote an Object).

Transition: An arrow indicating the Object to transition from one state to the
other. The actual trigger event and action causing the transition are written
beside the arrow, separated by a slash. Transition that occur because the
state completed and activity are called “triggerless” transitions. If an event
has to occur after the completion of some event or action, the event or action
is called the guard condition. The transition takes place after the guard
condition. The transition takes place after the guard condition occurs. This
guard condition/event/action is depicted by square brackets around the
description of the event/action.

History States: A flow may require that the object go to occur is called as an
event or action. Every transition need not occur due to the occurrence of an
event or action directly related to the state that transitioned from one state
to another.

Final State: the end of the state diagram is shown by a bull’s eye symbol also
called a final state. A final state is another example of a pseudo state
because it does not have any variable or action described.

Simple Set
A simple state is a state that does not have substates, i.e. it has no regions
and it has no submachine state machine.

Question 6 :
Explain different UML Diagrams used in OOAD. (10 Marks)

ANSWER:UML 2.0 has 13 types of diagrams divided into three categories.Six

diagram types represent the structure application, seven represent general
types of behavior, including four represent different aspects of interactions.
These diagrams can be categorized hierarchically as shown in the following
class diagram:
UML does not restrict UML element types to a certain diagram type. In
general, every UML element may appear on almost all types of diagrams.
This flexibility has been partially restricted in UML 2.0.
In keeping with the tradition of engineering drawings, a comment or note
explaining usage, constraint, or intent is always allowed in a UML diagram.
Structure diagrams
Structure diagrams emphasize what things must be in the system being
modeled:
Class diagram: describes the structure of a system by showing the system's
classes, their attributes, and the relationships among the classes.
Component diagram: depicts how a software system is split up into
components and shows the dependencies among these components.
Composite structure diagram: describes the internal structure of a class and
the collaborations that this structure makes possible.
Deployment diagram serves to model the hardware used in system
implementations, and the execution environments and artifacts deployed on
the hardware.
Object diagram: shows a complete or partial view of the structure of a
modeled system at a specific time.
Package diagram: depicts how a system is split up into logical groupings by
showing the dependencies among these groupings.
Class diagram

Component diagram

Composite structure diagrams

Deployment diagram

Object diagram

Package diagram

Since structure diagrams represent the structure of a system, they are used
extensively in documenting the architecture of software systems.
Behavior diagrams
Behavior diagrams emphasize what must happen in the system being
modeled:
Activity diagram: represents the business and operational step-by-step
workflows of components in a system. An activity diagram shows the overall
flow of control.
State diagram: standardized notation to describe many systems, from
computer programs to business processes.
Use case diagram: shows the functionality provided by a system in terms of
actors, their goals represented as use cases, and any dependencies among
those use cases.

UML Activity Diagram

State Machine diagram

Use case diagram

Since behaviour diagrams illustrate the behaviour of system, they are used
extensively to describe the functionality of software systems.
Interaction diagrams
Interaction diagrams, a subset of behavior diagrams, emphasize the flow of
control and data among the things in the system being modeled:
Communication diagram: shows the interactions between objects or parts in
terms of sequenced messages. They represent a combination of information
taken from Class, Sequence, and Use Case Diagrams describing both the
static structure and dynamic behavior of a system.
Interaction overview diagram: are a type of activity diagram in which the
nodes represent interaction diagrams.
Sequence diagram: shows how objects communicate with each other in terms
of a sequence of messages. Also indicates the lifespans of objects relative to
those messages.
Timing diagrams: are a specific type of interaction diagram, where the focus
is on timing constraints.

Communication diagram
Interaction overview diagram

Sequence diagram

Question 7:
Explain object model and dynamic model with example. (10 Marks)
Ans: The object model describes the structure of the objects in the system –
their identity, their relationship to other objects, their attributes, and their
operations. The object model depicts the primary view of how the real world
in which the system interacts is divided and the overall decomposition of the
system. The object model provides the framework into which the other
models are placed.

The object model is represented graphically with object class diagrams

containing the object classes and their relationships. Each application-domain
concept from the real world that is important to the application should be
modeled as an object class. Classes are arranged into hierarchies sharing
common structure and behavior and are associated with other classes.
Classes define the attributes carried by each object instance and the
operations that each object performs or undergoes.

The object class diagram should adhere to OMT’s notation and exploit the
capabilities of OMT, such as links and vasodilatations, inheritance
(generalization and specialization), and aggregation. The attributes and
operations need not be included in this diagram, as they will be described
below in the object class specification.

Elements of an Object Model

Object classes with attributes, relations and connections.
Attributes
Relations
Connection
Generalization/specialization
Aggregation
Classes with constraints no their environment
Behavior associated with an object model
Localization
The activity of establishing an object model consists of going through all the
elements of an object model.
Objects
The purpose of object modeling is to describe objects. For example, Joe
Smith, Simplex company, and the top window are objects. An object is simply
something that makes sense in an application context. Objects serves two
purposes: they promote understanding of the real world and provide a
practical basis for computer implementation. Decomposition fo a problem
into objects depends on judgments and the nature of the problem. There is
no one correct representation.
All objects have identity and are distinguishable. Two apples with the same
color, shape and texture are still individual apples; a person can eat one and
then eat the other.

Classes
An object class describes group with similar properties, common behavior,
common relationships to other objects, and common semantics, company,
animal, process, and window are all object classes. Ach person has an age,
IQ, and may work at a job. Ac process has an owner, priority, and list of
required resources. Objects and object classes often appear as nouns in
problem description.

The object in class share a common semantic purpose, above and beyond the
requirement of common attributes and behavior. Each object knows its class.

Question 8:
What is Unidirectional Implementation? Explain how it is different than Bi-
directional Implementation with an example. (10 Marks)

Ans.With a unidirectional association, you can navigate from one class to

another (As indicated by the direction of the arrow) but not vice-versa.It is
conveniently implemented using a reference. Associations represent
relationships between instances of types (a person works for a company, a
company has a number of offices…). The interpretation of them varies with
the perspective. Conceptually they represent conceptual relationships
between the types involved. In specification these are responsibilities for
knowing, and will be made explicit by access and update operations. This
may mean that a pointer exists between order and customer, but that is
hidden by encapsulation. A more implementation interpretation implies the
presence of a pointer. Thus it is essential to know what perspective is used to
build a model in order to interpret it correctly.

Associations may be bi-directional (Can be navigated in either direction) or

unidirectional (can be navigated in one direction only). Conceptually all
associations can be thought of a bi-directional, but unidirectional associations
are important for specification and implementation models. For coupling. IN
implementation models a bi-directional association implies coupled sets of
pointers, which many designers find difficult to deal with.

Bi-directional one-to-one associations

The following diagram indicates a bi-directional association no arrows on any
end of the association
It indicates that we must be able to navigate from an account to the
corresponding customer and vice versa. There are three approaches to bi-
directional implementation:
Implement as an attribute in one direction only and perform a search when a
backward traversal is required.
Implement as attributes in both directions.
Implement as a distinct association object, independent of either class.