Object Oriented Programming (OOP)

Last Updated: 12 November, 2023

Object-oriented programming (OOP) is a methodology of programming. Its main purpose is to deal with real-world entities using a programming language.

Object-oriented programming follows a bottom-up approach. It is highly secure because it supports OOPS (object-oriented programming) security features like access specifiers and data abstraction.

Object-oriented programming (OOP) is a widely used approach to programming, and many popular programming languages, such as Java, Python, and C++, support OOP.

The characteristics of object-oriented programming (OOP):

• Class

• Object

• Polymorphism

• Abstraction

• Encapsulation

• Inheritance

Class

A class is a user-defined data type in Java from which objects are created. It represents the set of properties, methods, etc. that are common to all objects of one type. A single Java class can have one or more objects.

A class is a logical entity that does not occupy any memory. Memory is only allocated if we create the object of a class.

To create a class, use the keyword class.

Java Class Syntax:

class class_name { // Blocks // Constructors // Variables // Methods // Nested Class // Nested Interface }

Read more →

Object

The object is an instance of a class in Java. The object is a real-world entity that has states and behavior. When a class is instantiated (i.e., an object is created), memory is allocated for that object.

In Java, we can usually create an object using a new keyword.

An object has the following characteristics:

1. State: It is represented by the attributes of an object. It also reflects the properties of an object.
2. Behavior: It represents the behavior (functionality) of an object, such as eating, jumping, etc.
3. Identity: It gives a unique name to an object and enables one object to interact with other objects.

Object creation syntax:

class_name object_name = new constructor_name();

For example, assume Student is a class name, and we are creating an object of the Student class.

Example: Java class and object creation

class ProductDetails { // Instance Block { System.out.println("Product Information"); } // Variables String product_name; float price; // Constructor public ProductDetails() { System.out.println("Product class - Default Constructor"); product_name = "Pen"; price = 20.5f; } // Method void getProductDetails() { System.out.println("Product Name: " + product_name); System.out.println("Price: " + price); } } public class Product { public static void main(String[] args) { // Creating object of ProductDetails class ProductDetails productDtl = new ProductDetails(); // After creating the object, calling method with the help of object name productDtl.getProductDetails(); } }

Output

Product Information
Product class - Default Constructor
Product Name: Pen
Price: 20.5

Read more →

Polymorphism

Polymorphism is one of the strong core features of object-oriented programming (OOP) that allows us to perform a single action in different ways.

Polymorphism is a combination of the two Greek words Poly and Morphs where "Ploy" means many and “Morphs” means forms. Therefore, polymorphism means “many forms”.

There are two types of Polymorphism in Java:

1. Compile-Time Polymorphism
2. Run-Time Polymorphism

Compile-Time Polymorphism

We can achieve compile-time polymorphism using method overloading in Java, which means in the same Java class we write two or more methods with the same method name but different parameters.

This polymorphism is resolved during compilation time. We can achieve compile-time polymorphism through method overloading.

Compile-time polymorphism is also known as static polymorphism in Java.

Run-Time Polymorphism

We can achieve run-time polymorphism using method overriding in Java. Method overriding can be performed only in inheritance (the IS-A relationship), which means we declare the same method in both parent and child classes with the same signature.

"Method overriding" is the process of redefining a method in a child class that is already defined in the parent class. When both parent and child classes have the same method, then that method is said to be the overriding method. The method overriding enables the child class to change the implementation of the method acquired from the parent class according to its requirements.

This polymorphism is resolved during runtime and is achieved through method overriding. It is also known as "dynamic method dispatch."

Read more →

Abstraction

Abstraction is one of the strong concepts of object-oriented programming (OOP).

Abstraction is a mechanism of hiding the implementation details and showing only functionality to the user. For example, we use mobile phones every day, but we know only the functionality of the phones but not their internal details.

There are two ways to achieve abstraction in Java:

1. Abstract Class (0-100% abstraction)

2. Interface (100% abstraction)

📝 Using the Interface we can achieve 100% abstraction (complete abstraction) whereas through the abstract class we can achieve 0-100% abstraction (partial or complete abstraction) depending on the implementation of the abstract class.

Advantage of Abstraction:

• Abstraction increases java application security.
• Avoids code duplication and increases reusability.

Read more →

Encapsulation

Object-Oriented Programming (OOP) is based on four core concepts: abstraction, encapsulation, inheritance, and polymorphism.

In this article, we are going to discuss all about encapsulation in Java with examples.

Encapsulation is the mechanism of wrapping data (variables) and behavior (methods) together in a single unit (class).

The data of an encapsulated class will be hidden from other classes and cannot be accessed directly outside of it. It can only be accessed outside of the class through the public methods of its current class. Encapsulation helps achieve data hiding in Java.

An example of a fully encapsulated class is the Java Bean class.

To achieve encapsulation in Java:

Declare the variables of a class as private.
Other classes cannot directly access private variables.

Provide public setter and getter methods.
Using these public methods, private variables can be accessed or modified outside of the class.

The advantages of encapsulation in Java:

• Encapsulation provides better control of class attributes and methods.
• Encapsulation provides flexibility in Java programming. The programmer can change one part of the code without affecting other parts.
• Encapsulation provides data security, which means we should declare private access modifiers with sensitive data (variables) and methods so that no one outside the class can directly access these private properties.
• Class attributes can be made read-only if we use the get public methods or write-only if we use the set public methods.
• Encapsulation provides easy debugging and testing, so it is good for unit testing.
• Encapsulation allows the user to effectively use the existing code multiple times.

Read more →

Inheritance

Inheritance is a strong pillar of Object-Oriented Programming (OOP), and it provides a mechanism in Java for allowing access (to inherit) to all properties such as variables and methods (non-private properties only) from one class to another.

• The class that inherits the properties is called the subclass, child class, or derived class.
• The class from which the properties are inherited is called the Super Class, Parent Class, or Base Class.

The extends keyword is used to implement the concept of inheritance in Java.

Inheritance Syntax in Java

class Parent { // variables // methods } class Child extends Parent { // variables // methods }

Types of Inheritance in Java

There are five types of inheritance supported by Java.

1. Single Inheritance
2. Multilevel Inheritance
3. Hierarchical Inheritance
4. Multiple Inheritance
5. Hybrid Inheritance

Read more →