Object Oriented Programming (OOPs)

Concept in Java
As the name suggests, Object-Oriented Programming or OOPs refers to languages that use
objects in programming, they use objects as a primary source to implement what is to
happen in the code. Objects are seen by the viewer or user, performing tasks assigned by
you. Object-oriented programming aims to implement real-world entities like inheritance,
hiding, polymorphism etc. in 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.
Let us discuss prerequisites by polishing concepts of method declaration and message
passing. Starting off with the method declaration, it consists of six components:
 Access Modifier: Defines the access type of the method i.e. from where it can
be accessed in your application. In Java, there are 4 types of access specifiers:
 public: Accessible in all classes in your application.
 protected: Accessible within the package in which it is defined and in its
subclass(es) (including subclasses declared outside the
package).
 private: Accessible only within the class in which it is defined.
 default (declared/defined without using any
modifier): Accessible within the same class and package within which
its class is defined.

 The return type: The data type of the value returned by the method or void if it
does not return a value.
 Method Name: The rules for field names apply to method names as well, but the
convention is a little different.
 Parameter list: Comma-separated list of the input parameters that are defined,
preceded by their data type, within the enclosed parentheses. If there are no
parameters, you must use empty parentheses ().
 Exception list: The exceptions you expect the method to throw. You can
specify these exception(s).
 Method body: It is the block of code, enclosed between braces, that you need
to execute to perform your intended operations.
OOPS concepts are as follows:
1. Class
2. Object
3. Pillars of OOPs
 Abstraction
 Encapsulation
 Inheritance
 Polymorphism
CLASS:
A class is a user-defined blueprint or prototype from which objects are created. It represents
the set of properties or methods that are common to all objects of one type. Using classes,
you can create multiple objects with the same behavior instead of writing their code
multiple times. This includes classes for objects occurring more than once in your code. In
general, class declarations can include these components in order:
1. Modifiers: A class can be public or have default access (Refer to this for details).
2. Class name: The class name should begin with the initial letter capitalized by
convention.
3. Superclass (if any): The name of the class’s parent (superclass), if any, preceded by
the keyword extends. A class can only extend (subclass) one
parent.
4. Interfaces (if any): A comma-separated list of interfaces implemented by the class, if
any, preceded by the keyword implements. A class can implement more than one
interface.
5. Body: The class body is surrounded by braces, { }.

OBJECT:
An object is a basic unit of Object-Oriented Programming that represents real- life
entities. A typical Java program creates many objects, which as you know, interact by
invoking methods. The objects are what perform your code, they are the part of your
code visible to the viewer/user. An object mainly consists of:
6. State: It is represented by the attributes of an object. It also reflects the properties of an
object.
7. Behavior: It is represented by the methods of an object. It also reflects the response of an
object to other objects.
8. Identity: It is a unique name given to an object that enables it to interact with other
objects.
9. Method: A method is a collection of statements that perform some specific task and
return the result to the caller. A method can perform some specific task without
returning anything. Methods allow us to reuse the code without retyping it, which is why
they are considered time savers. In Java, every method must be part of some class,
which is different from languages like C, C++, and Python.
Let us now discuss the 4 pillars of OOPs:
Pillar 1: Abstraction
Data Abstraction is the property by virtue of which only the essential details are
displayed to the user. The trivial or non-essential units are not displayed to the user. Ex:
A car is viewed as a car rather than its individual components. Data Abstraction may
also be defined as the process of identifying only the required characteristics of an
object, ignoring the irrelevant details. The properties and behaviors of an object
differentiate it from other objects of similar type and also help in classifying/grouping
the object.

Consider a real-life example of a man driving a car. The man only knows that pressing the
accelerators will increase the car speed or applying brakes will stop the car, but he does
not know how on pressing the accelerator, the speed is actually increasing. He does not
know about the inner mechanism of the car or the implementation of the accelerators,
brakes etc. in the car. This is what abstraction is.
In Java, abstraction is achieved by interfaces and abstract classes. We can
achieve 100% abstraction using interfaces.

Pillar 2: Encapsulation
It is defined as the wrapping up of data under a single unit. It is the mechanism
that binds together the code and the data it manipulates. Another way to think about
encapsulation is that it is a protective shield that prevents the data from being accessed
by the code outside this shield.
 Technically, in encapsulation, the variables or the data in a class is hidden from any
other class and can be accessed only through any member function of the class in
which they are declared.
 In encapsulation, the data in a class is hidden from other classes, which is similar to
what data-hiding does. So, the terms “encapsulation” and “data- hiding” are used
interchangeably.
 Encapsulation can be achieved by declaring all the variables in a class as private and
writing public methods in the class to set and get the values of the variables.

Pillar 3: Inheritance
Inheritance is an important pillar of OOP (Object Oriented Programming). It is the
mechanism in Java by which one class is allowed to inherit the features (fields and
methods) of another class.
Let us discuss some frequently used important terminologies:
 Superclass: The class whose features are inherited is known as superclass (also
known as base or parent class).
 Subclass: The class that inherits the other class is known as subclass (also known as
derived or extended or child class). The subclass can add its own fields and methods in
addition to the superclass fields and methods.
 Reusability: Inheritance supports the concept of “reusability”, i.e. when we want to
create a new class and there is already a class that includes some of the code that we
want, we can derive our new class from the existing class. By doing this, we are
reusing the fields and methods of the existing class.

Pillar 4: Polymorphism
It refers to the ability of object-oriented programming languages to differentiate between
entities with the same name efficiently. This is done by Java with the help of the
signature and declaration of these entities.