Unit 1 introduces the basics of object-oriented programming (OOP). OOP treats data as objects that contain both data fields (properties) and methods (behaviors). Classes are templates that are used to create objects. Some key principles of OOP include encapsulation, which binds an object's data and methods together, inheritance which allows classes to share structures and behaviors of other classes, and polymorphism which allows different classes to have similarly-named methods that work in different ways. OOP aims to make code reusable, modular, and adaptable to changing requirements compared to traditional procedural programming.

1. Unit 1 : Introduction and Basics of OOP’s
Object means a real word entity such as pen, chair,
table etc.
Object-Oriented Programming is a methodology or
paradigm to design a program using classes and
objects.

2. Introduction to Object Oriented Paradigm :-
• The main necessity behind inventing object oriented approach is to remove
the drawback encountered in the procedural approach.
• The programming paradigm object treats data as an element in the program
development.
• It ties the data to the function that operates on it and hides and protects it
from accidental updates by external functions.
• Object oriented programming paradigm allows decomposition of the system
into the number of entities called objects and then ties properties and
function to these objects.
• An object’s properties can be accessed only by the functions associated with
that object but functions of one object can access the function of other
objects in the same cases using access specifiers.

3. Need Object Oriented Programming :-
• The main aim of OOP is to bind together the data and the
functions that operate on them so that no other part of the
code can access this data except that function.
• With the use of classes and objects, object-oriented
programming makes code maintenance simple. Because
inheritance allows for code reuse, the program is simpler
because you don't have to write the same code repeatedly.
Data hiding is also provided by ideas like encapsulation and
abstraction.
• The software produced using object-oriented programming
paradigm is easier to adapt to the changing requirements,
easier to maintain, create modules of functionality, promote
greater design, be more robust, and perform desired work
efficiently.

4. Characteristics of OOP’s :-
• Object
• Class
• Inheritance
• Polymorphism
• Abstraction
• Encapsulation

5. • Object :
Any entity that has state and behavior is known as an
object. For example: chair, pen, table, keyboard, bike etc. It
can be physical and logical.
• Class :
Collection of objects is called class. It is a logical entity.
A Class in C++ is the foundational element that leads to
Object-Oriented programming.
A class instance must be created in order to access and
use the user-defined data type's, data members and
member functions. An object's class acts as its blueprint.
Ex. Car Class. Even if different names and brands may be
used for different cars, all of them will have some
characteristics in common, such as four wheels, a speed
limit, a range of miles, etc. In this case, the class of car is
represented by the wheels, the speed limitations, and the
mileage.

6. • Inheritance :
When one object acquires all the properties and
behaviours of parent object i.e. known as inheritance.
It provides code reusability. It is used to achieve
runtime polymorphism.
Sub class - Subclass or Derived Class refers to a class that
receives properties from another class.
Super class - The term "Base Class" or "Super Class" refers
to the class from which a subclass inherits its properties.
Reusability - As a result, when we wish to create a new
class, but an existing class already contains some of the
code we need, we can generate our new class from the
old class. This allows us to utilize the fields and methods
of the pre-existing class.

7. • Polymorphism :
Polymorphism means "many forms", and it occurs when
we have many classes that are related to each other by
inheritance.
Let's consider a real-life example of polymorphism. A lady
behaves like a teacher in a classroom, mother or daughter in a
home and customer in a market. Here, a single person is
behaving differently according to the situations.
Polymorphism is considered one of the important
features of Object-Oriented Programming.

8. • Abstraction :
Data Abstraction is a process of providing only the
essential details to the outside world and hiding the internal
details, i.e., representing only the essential details in the
program.
Let's take a real life example of AC, which can be
turned ON or OFF, change the temperature, change the
mode, and other external components such as fan, swing.
But, we don't know the internal details of the AC, i.e., how it
works internally. Thus, we can say that AC seperates the
implementation details from the external interface.
C++ provides a great level of abstraction. For example,
pow() function is used to calculate the power of a number
without knowing the algorithm the function follows.

9. • Encapsulation :
Binding (or wrapping) code and data together into a single unit is known as
encapsulation.
For example: capsule, it is wrapped with different medicines.
Encapsulation is typically understood as the grouping of related pieces of
information and data into a single entity.

10. • Difference of Structured Vs. OOPs
Sr no. Structured Programming Object-Oriented Programming
1 Programs are divided into small programs or
functions.
Programs are divided into objects or
entities.
2 It is all about facilitating creation of programs with
readable code and reusable components.
It is all about creating objects that usually
contain both functions and data.
3
Its main aim is to improve and increase quality,
clarity, and development time of computer program.
Its main aim is to improve and increase both
quality and productivity of system analysis
and design.
4 It is a method of organizing, managing and coding
programs that can give or provide much easier
modification and understanding.
It is a method in which set of objects can
vary dynamically and can execute just by
acting and reading to each other.
5 It generally follows “Top-Down Approach”. It generally follows “Bottom-Up Approach”.
6 It is more difficult to modify structured program and
reuse code as compared to object-oriented
programs.
It is less difficult to modify object-oriented
programs and reuse code as compared to
structured programs.
7
It gives more importance of code. It gives more importance to data.