OOPs Concepts in Java

What Are OOPs Concepts in Java?

Object-Oriented Programming System (OOPs) is a programming concept that works on the principles of abstraction, encapsulation, inheritance, and polymorphism. It allows users to create objects they want and create methods to handle those objects. The basic concept of OOPs is to create objects, re-use them throughout the program, and manipulate these objects to get results.

OOP, which stands for Object-Oriented Programming, is a popularly known and widely used concept in modern programming languages like Java. Java OOPs Concepts give developers a clean way to model real-world entities, organize logic into reusable units, and reduce duplicated code across large applications.

Why Use OOPs Concepts in Java?

Java OOPs Concepts solve several long-standing problems that plagued procedural code. By grouping data and behavior together inside classes, developers can reason about each module in isolation and update it without breaking the rest of the system.

• OOPs Concepts in Java offer easy to understand and a clear modular structure for programs.
• Objects created for Object-Oriented Programs can be reused in other programs, which saves significant development cost.
• Large programs are difficult to write, but if the development and designing team follow OOPs Concepts, they can design with minimum flaws.
• It enhances program modularity because every object exists independently.

OOPs Concepts in Java with Examples

The following are general OOPs Concepts in Java that every developer should know before writing production-grade code.

1) Class

The class is one of the basic concepts of OOPs which is a group of similar entities. It is only a logical component and not the physical entity. To understand this OOPs Concept with an example, if you had a class called “Expensive Cars”, it could have objects like Mercedes, BMW, Toyota, etc. Its properties (data) can be price or speed of these cars. The methods performed on these cars include driving, reverse, and braking.

2) Object

An object can be defined as an instance of a class, and there can be multiple instances of a class in a program. An Object is one of the Java OOPs Concepts which contains both the data and the function that operates on the data. For example, chair, bike, marker, pen, table, and car are all objects.

3) Inheritance

Inheritance is one of the basic concepts of OOPs in which one object acquires the properties and behaviors of the parent object. It creates a parent-child relationship between two classes. It offers a robust and natural mechanism for organizing and structuring any software.

4) Polymorphism

Polymorphism refers to one of the OOPs Concepts in Java which is the ability of a variable, object, or function to take on multiple forms. For example, in English, the verb run has a different meaning if you use it with a laptop, a foot race, and business. Here, we understand the meaning of run based on the other words used along with it. The same also applies to Polymorphism.

5) Abstraction

Abstraction is one of the OOPs Concepts in Java which is an act of representing essential features without including background details. It is a technique of creating a new data type that is suited for a specific application. To understand this OOPs Concept with an example, while driving a car you do not have to be concerned with its internal working. Here you just need to concern about parts like steering wheel, gears, and accelerator.

6) Encapsulation

Encapsulation is one of the best Java OOPs Concepts of wrapping the data and code. In this OOPs Concept, the variables of a class are always hidden from other classes. They can only be accessed using the methods of their current class. For example, in school, a student cannot exist without a class.

7) Association

Association is a relationship between two objects. It is one of the OOPs Concepts in Java which defines the diversity between objects. In this OOP concept, all objects have their separate lifecycle, and there is no owner. For example, many students can associate with one teacher while one student can also associate with multiple teachers.

8) Aggregation

In this technique, all objects have their separate lifecycle. However, there is ownership such that a child object cannot belong to another parent object. For example, consider class/objects department and teacher. Here, a single teacher cannot belong to multiple departments, but even if we delete the department, the teacher object will never be destroyed.

9) Composition

Composition is a specialized form of Aggregation. It is also called a “death” relationship. Child objects do not have their lifecycle so when the parent object is deleted, all child objects will also be deleted automatically. For that, let’s take an example of House and rooms. Any house can have several rooms. One room cannot become part of two different houses. So, if you delete the house, the room will also be deleted.

Comparison of OOPs with Other Programming Styles

Let’s understand with an example how Java OOPs Concepts differ from other programming approaches.

Programming languages can be classified into 3 primary types:

1. Unstructured Programming Languages: The most primitive of all programming languages having a sequential flow of control. Code is repeated throughout the program.
2. Structured Programming Languages: These have a non-sequential flow of control. The use of functions allows for re-use of code.
3. Object-Oriented Programming Languages: These combine Data and Action together.

Click here if the video is not accessible

Let’s understand these 3 types with an example. Suppose you want to create a Banking Software with functions like:

1. Deposit
2. Withdraw
3. Show Balance

Unstructured Programming Languages

The earliest of all programming languages were unstructured programming languages. A very elementary code of a banking application in an unstructured programming language will have two variables, one for account number and another for account balance.

int account_number=20;
int account_balance=100;

Suppose a deposit of 100 dollars is made.

account_balance=account_balance+100

Next you need to display the account balance.

printf("Account Number=%d",account_number)
printf("Account Balance=%d",account_balance)

Now the amount of 50 dollars is withdrawn.

account_balance=account_balance-50

Again, you need to display the account balance.

printf("Account Number=%d",account_number)
printf("Account Balance=%d",account_balance)

For any further deposit or withdrawal operation, you will repeat the same lines of code again and again.

Structured Programming

With the arrival of structured programming, repeated lines in the code were put into structures such as functions or methods. Whenever needed, a simple call to the function is made, which reduces duplication and makes maintenance easier.

Object-Oriented Programming

In our program, we are dealing with data or performing specific operations on the data. In fact, having data and performing certain operations on that data is a very basic characteristic of any software program. Experts in software programming thought of combining the data and operations. This led to the birth of Object-Oriented Programming, commonly called OOPs. The same code in Object-Oriented Programming languages will have the same data and some action performed on that data.

Class Account{
    int account_number;
    int account_balance;
public void showdata(){
    system.out.println("Account Number"+account_number)
    System.out.println("Account Balance"+ account_balance)
}
}

By combining data and action, we gain many advantages over structured programming, including:

• Abstraction
• Encapsulation
• Inheritance
• Polymorphism

These four pillars are discussed in greater detail in succeeding tutorials and form the foundation of every modern Java application.

FAQs