- Trending Categories
- Data Structure
- Operating System
- C Programming
- Social Studies
- Fashion Studies
- Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Object-oriented Life Cycle Model in Software Engineering
The object-oriented life cycle model considers 'objects' as the basis of the software engineering process. The development team starts by observing and analyzing the system they intend to develop before defining the requirements. Once the process is over, they focus on identifying the objects of the system. Now, an object could be anything; it can have a physical existence like a customer, car, etc. An object also constitutes intangible elements like a process or a project.
Advantages of Object-Oriented Life Cycle Model
Apart from enhancing the system performance, object-oriented programming offers some advantages such as:
Since it is data-focused and easy to work with problem domains.
It uses encapsulation and data hiding process that allows a developer to build tamper-proof systems.
It enables software modularity, making it easier to manage and maintain complex software.
It allows developers to create new modules using existing models, saving time and development cost of organizations.
The primary objectives of the Object-Oriented Model
- Object-oriented Analysis
- Object-oriented Design
- Object-oriented Implementation
Object-Oriented Analysis (OOA)
The object-oriented analysis consists of the process where a development team evaluates the system and organizes the requirements as objects. Contrary to traditional structural analysis, the OOA heavily depends on advanced data like Use Cases and Object Models.
Use Cases are written descriptions about how users will behave when they enter your website or application. It comprises the goals of each user from the point of their entry to exit.
An object model allows the development team to create an architectural software or system model before implementing or programming. It helps in defining a software/system in objects and classes. It informs the developers about
- Interaction between different models
- Other types of object-oriented interfaces
The OOA starts with analyzing the problem domain and produce a conceptual model by thoroughly evaluating the information in the given area. There is an abundance of data available from various sources like:
- Formal document
- Requirement statements
- Primary data collected through stakeholders
Once the analysis is complete, the development team prepares a conceptual model describing the system's functionalities and requirements.
It is the next development stage of the object-oriented life cycle model where the analysts design the desired system's overall architecture. The system is divided into a set of interacting subsystems. The analyst considers the specifications from the system analysis. It all about evaluating what the end-users expect from the new system.
As per the object-oriented design, the system is considered a collection of objects, with each object handling a specific state data. For example, in banking software, each account may feature some exclusive objects with separate data and functions.
The philosophy behind an object-oriented design is to create a set of interacting objects as seen in the real world. Instead of process-based structural programming, developers create objects through data structures.
Each programming language comes with several data types, with each type comprising various variables. Similarly, objects also feature certain predefined data types.
Useful definitions for Object-oriented design
A class refers to a collection of similar objects. It is created as a blueprint to define variables and methods that share certain similarities with objects.
As stated above, an object-oriented design bears resemblances with the real world. Let's say you have purchased a smartphone. Now, your smartphone is just one of the several 'smartphones' available in the world. We can consider 'smartphones' as a class of objects, and your smartphone object is an instance of a class of objects. Smartphones feature many states (operating System, RAM, and motherboard) and behavior (play music, call, messaging) in common. However, the state of each smartphone is independent and can be different from other smartphones.
While manufacturing smartphones, manufacturers can use the exact blueprint to build many smartphones as they share common characteristics. This allows manufacturers to create new blueprints more efficiently.
Likewise, in object-oriented programming, developers can use many similar objects to create blueprints. This is called a class.
Abstraction is the essence used by developers to build classes. Developers observe a set of similar objects and characteristics of importance to define classes. Abstractions are divided into two parts- global abstractions and local abstractions.
Global abstractions are static, providing one interface to users for a limited time. Meanwhile, Local abstractions are responsible for providing a view based on user/developer's requirements.
The abstraction of objects varies as per the application. For example, while defining a smartphone class of users, developers might set attributes like color, features, price, etc. However, for manufacturing firms, developers may set attributes containing such as the manufacturing costs per smartphone, quality control, turnaround, etc.
The concept of inheritance in object-oriented design defines the process of reusing 'objects.' Developers can define a new class type using a similar existing class.
For example, hatchbacks, sedans, SUVs, and 4wds are all a form of motor vehicles. So, as per object-oriented programming, we can refer to hatchbacks, sedans, SUVs, etc., as subclasses of the motor vehicle class. Similarly, the motor vehicle class is the superclass of the subclasses.
Now, each subclass (sedans, hatchback, SUVs) inherits some states (speed, cadence, etc.), methods, and behaviors (braking, changing gear) of the superclass. However, the state and behaviors of subclasses are not limited to what has been provided to them by the superclass. Developers can add variables and methods to subclasses as required.
In this phase, developers translate the class objects and the interrelationships of classes and code them using a programming language. This is the phase to create databases and establish functionalities for the system.
The object-oriented methodology focuses on identifying objects in the system. Developers closely observe each object to identify characteristics and behavioral patterns. The developers ensure that the object recognizes and responds perfectly to an event.
Let's consider a smartphone screen as an object and the touch on a specific icon as an event. Now, when the user touches an icon, the screen opens up an application. This means the smartphone screen (object) responds to the event (touch) by opening an application.
The object-oriented implementation methodology supports three basic models
Object Model − It describes the objects and their interrelationships. This model observes objects as static and discards their dynamicity.
Dynamic Model − This model focuses on the changes in states of various objects related to specific events.
Functional Model − This describes the changes in the flow of data throughout the system.
The object model describes the essential elements of a system. When all the models are combined, it represents the complete function of the system.
- Selection Process Parameters for a Software Life Cycle Model
- Bug Life Cycle in Software Development
- Software Testing Life Cycle (STLC) Phases
- Object-oriented Data Model
- What are the phases of Software Development Life Cycle (SDLC)?
- Comparison between E-R Model and Object Oriented Model
- Explain the object oriented data model in DBMS?
- Accessibility Testing in Software Engineering
- Comparison Testing in Software Engineering
- Curve Fitting Models in Software Engineering
- Agile Development Models in Software Engineering
- Cost Estimation Models in Software Engineering
- Principles of Conventional Software Engineering
- Database Life Cycle
- Ant Life Cycle