This document provides an overview of object-oriented concepts, principles, and software development. It defines key object-oriented terms like class, object, encapsulation, inheritance, and polymorphism. It also describes the three phases of object-oriented software development: object-oriented analysis, design, and construction. Object-oriented analysis identifies classes, objects, relationships, and system requirements. Design further develops the static and dynamic models. Construction implements the analysis and design models based on the programming language environment.

1. T.Y.B.Sc.(Comp. Sci.) Sem. I
Object Oriented Software Engineering
(OOSE)
CS-336
Faculty
Dr. Amit D. Kasliwal
Asst. Professor

2. Chapter 1
Object Oriented Concepts and Principles
 The Software Engineering is a systematic approach to the design,
development, operation and maintenance of a software.
 Series of processes, if followed can lead to development of a software.
 Based on functions or procedures with limited reusability of
programming structure.
 And sometimes also referred to as Traditional Software engineering.
 The size and complexity of software is increasing day by day.
 And traditional software engineering may not be effectively applicable.
 So we want to simplify the development process and to produce high
quality maintainable software to fulfill user requirements.

3. What is Object Orientation ?
 Object Orientation is viewing and modeling the real world entities as a
collection of interacting and interrelated objects.
 An object is a real world entity or element in an object oriented
environment that encapsulates (combine) data and the functionalities
to model real world.
 Object may have a physical or a conceptual existence such a,
 That distinguishes it from other objects.
 That determines the characteristic or properties as well as the values
of the properties that the object holds.
 That represents externally visible activities performed by an object
in terms of changes in its state.
 Objects can be modeled according to the needs of the application.

4.  In Object oriented environment, the software is developed by building
self modeled objects that can be easily replaced and reused.
 Object orientation encourage the world to view a software as a
cooperative and collaborating objects.
 An object is an entity that save it’s state (data) and offers several
methods (behaviors) to either examine or affect this states.
What is Object Orientation ?

5.  A Class represents a collection of objects having same characteristic or
properties that follows common behavior.
 Blueprint or description of the objects that can be created from it.
 Creation of an object as a part (member ) of a class is called instantiation.
That is “object is an instance of a class.”
 A set of objects with similar behavior & data/information may constitute
a class.
 In general, different objects of a class have some difference in the values
of the attributes.(and attributes are often referred as class data)
 A set of methods refers the behavior of the objects of the class.
 Let us consider a class named Book, with attribute subjectdescriptor ,
ISBN, booktitle , language, authorname , publisher and so on. Some of
its operations like addbook(), deletebook(), updatebook() & viewbook().
What is Object Orientation ?

6. What is Object Orientation ?

7.  So we can say, object orientation relies on two aspects i.e. Information
and Behavior.
 Information has a unique identity.
 It has a description of its structure used to create it.
 And has state to represent its current condition.
 Behavior is to answers the questions like,
 What can an object do?
 What we can do with the object?
 How a object can be use?
What is Object Orientation ?

8.  In Object orientation approach, encapsulation, polymorphism and
inheritance concepts as used.
 Encapsulation is the process of hiding information by combining the
data and operations.
 It allows to access the data only through the that operations which are
designed to operate on the data.
 Its keeps data safe and secure from external interventions.
What is Object Orientation ?

9.  Polymorphism is originally a Greek word that means the ability to take
multiple forms. The dictionary meaning is “many forms”.
 In object oriented, polymorphism implies using operations in different
ways, depending upon the instance they are operating upon.
 Like in the real world, the same operations may have different
meanings in different situations.
 Same data is sent to different objects irrespective of their class, but the
responses of objects may be different.
 Polymorphism allows objects with different internal structures to have
a common external interface.
 Polymorphism is particularly effective while implementing inheritance.
What is Object Orientation ?

10.  In object orientation, Inheritance allows creating new classes from
existing classes by extending and refining its capabilities.
 The existing classes are called the base / parent / super classes, and the
new classes are called the derived / child / sub classes.
 The subclass can inherit or derive the attributes and methods of the
super class /classes provided that the super-class allows so.
 Beside this, the subclass may add its own attributes and methods and
may modify any of the super-class methods.
 Following are the inheritance type.
 Single Inheritance Multiple Inheritance
 Multilevel Inheritance Hierarchical Inheritance
 Hybrid Inheritance
What is Object Orientation ?

11. What is Object Orientation ?

12. Object Oriented System Development
 In order to develop a system / software, a systematic approach should be
adopted satisfying two viewpoint, Internal and External
 In Internal viewpoint, everything about the software (from the developer
view) has to be maintain so that it can be easily modify, extend & reuse.
 With External viewpoint (From the user view), it has to be accurate in
result generation, reliable and easy to learn and adopt.
 And thus to satisfy the individual's viewpoint the , A use case driven
approach (Considering Object Orientation in the center) of software
engineering was prepared referred as Object Oriented Software
Development(OOSD) having SDLC consisting of three phases.
 Object Oriented analysis (OOA), Object Oriented Design (OOD) and
Object Oriented Construction (OOC)

13. Object Oriented System Development

14.  Object Oriented Analysis in OOSD concerned with determining the
system requirement, identifying classes and relationships between
classes in the required domain.
 OOA also identifies users (actors) and how they use the software.
 It always consider the scenario to help the analyst to understand the
requirements as mentioned by the end user.
 According the Ivor Jacobson, OOA works with use case diagram to
understand the scenario to describe end user’s interaction with
software.
 It helps in determining who does what in the interaction among objects
and what role end users plays by using their relationship.
 OOA supports collaboration that describes the interaction among
objects to achieve given goal.
Object Oriented Analysis

15.  In OOA, three analysis techniques Object modeling, Dynamic
modeling, and functional modeling are used.
 Object Modeling develops the static structure of the software in terms
of objects.
 It identifies the objects, the classes into which the objects can be
grouped into and the relationships between the objects.
 It also identifies the main attributes & operations of each class.
 It can be visualized in the following steps −
 Identify objects and group into classes and their relationships
 Define user object attributes
 Define the operations that should be performed on the classes
 Review glossary
Object Oriented Analysis

16.  Functional Modeling is the final component of OOA.
 It shows the processes that are performed within an object and how the
data changes as object moves between methods.
 It specifies the meaning of the operations of object modeling and the
actions of dynamic modeling.
 It corresponds to the data flow diagram of traditional analysis process.
 It has the following steps −
 Identify all the inputs and outputs
 Construct data flow diagrams showing functional dependencies
 State the purpose of each function
 Identify constraints
 Specify optimization criteria
Object Oriented Analysis

17.  In Dynamic Modeling, software’s behavior with respect to time and
external changes are prepared after the static behavior is analyzed.
 It is a way of describing how an individual object responds to events,
either internal events triggered by other objects, or external events
triggered by the outside world.
 It has following steps −
 Identify states of each object
 Identify events and analyze the applicability of actions
 Construct dynamic model diagram, comprising of state transition
diagrams
 Express each state in terms of object attributes
 Validate the state–transition diagrams drawn
Object Oriented Analysis

18.  The analysis model is not sufficiently formal but still we follows the
OOA to develop a software.
 Constructed software must be adapted to the implementation
environment such that it validate the analysis result.
 OOC phase use to identify the implementation environment.
 It helps in identifying and investigating the consequences that the
implementation environment will have after design.
 It incorporate conclusions and develop a first approach of a design
model.
 OOC uses process combining sub processes of designing, building
Model.
 It redefine the analysis model in the light of the actual implementation.
Object Oriented Construction

19.  In OOC, designing model decide how different issues such as DBMS,
programming language features, and distribution will be handled.
 It compose of blocks of code which are specific to class.
 In the Building model of OOC, developers attempt to implement
analysis model using programming language.
 It is used obtain a clear traceability to the analysis model.
 It works for final structure that should reflect how the implementation
environment has affected construction.
 E.g. if the programming language does not support inheritance, the
model must reflect how the inheritance is really implemented.
Object Oriented Construction

20. Development

21. Identifying the Classes and Object
 When we look around the problem of a software application, the objects
may be more difficult to comprehend.
 We can identify objects by examining the problem statement given for
the software with performing grammatical parse.
 Objects are determined by underlining each noun or noun clause and
entering it in a simple table. Also synonyms should be noted.
 If the object is required to implement a solution, then it is part of the
solution space.
 Objects can be External entities (e.g., other systems, devices, people) ,
Things (e.g., reports, displays, letters, signals), Occurrences or events
(e.g., a property transfer or the completion of a series of robot
movements), Roles (e.g., manager, engineer, salesperson), Organizational
units (e.g., division, group, team), Places (e.g., manufacturing floor or
loading dock) or Structures (e.g., sensors, four-wheeled vehicles, or
computers).

22.  The analysis process starts with the identification of a set of conceptual
classes – the categories of things which are of significance in the system
domain. A good understanding of the system domain is important.
 A class in a model is thing that represents a category of real-world entities
from the system domain.
 Although these may be tangible real world things, they may also be
intangible things such as events, roles and organizational units.
 The software developer often gains this through discussion with user.
 Possible classes for inclusion may thus emerge during the course of the
requirements process.
 However, there are a number of other techniques that you can use to help
identify appropriate classes from a requirements document.
 Inappropriately chosen classes may add complexity to later phases of the
development and could make the software difficult to maintain and/or
extend.
Identifying the Classes and Object

23. Classes and Object

24. Specifying the Attributes (With Visibility)
 Attributes describe an object that has been selected for inclusion in the
analysis model.
 It is the attributes that define the object clarifying what is meant by the
object in the context of the domain.
 To specify a meaningful set of attributes for an object, the analyst can
again study the requirement for the problem and select those things
that reasonably "belong" to the object.
 In addition, it must be the answered of the question "What data items
define this object in the context of the problem?"
 Each of the data items in the block could be
further defined to an elementary level, but
for our purposes, they constitute a reasonable
list of attributes for an object .

25. Defining Operations
 Operations define the behavior of an object and change the object’s
attributes in some way.
 Specifically, an operation changes one or more attribute values that are
contained within the object.
 Therefore, an operation must have knowledge of the nature of the
object's attributes
 It must be implemented in a manner that enables to manipulate the
data structures that have been derived from the attributes.
 Although many different types of operations exist, they can generally
be divided into three broad categories:
 operations that manipulate data in some way (e.g., adding, deleting,
reformatting, selecting),
 operations that perform a computation,
 operations that monitor an object for the occurrence of a controlling
event.

26. Finalizing the Object Definition
 The definition of operations is the last step in completing the
specification of an object.
 Operations were picked from a grammatical parse of the processing
narrative for the system.
 Additional operations may be determined by considering the "life
history" of an object and the messages that are passed among objects
defined for the system.
 The generic life history of an object can be defined by recognizing that
the object must be created, modified, manipulated or read in other
ways, and possibly deleted.