Abstraction vs Encapsulation: Difference Between Abstraction and Encapsulation

by Rohan Vats

Software Engineering Manager @ upGrad. Passionate about building large scale web apps with delightful experiences. In pursuit of transforming engineers into leaders.

Feb 9, 2021

7 min read

Table of Contents

Introduction

Every programmer thrives to develop a neat and clean code, and he must use a proper weapon from armour or OOP concepts. Using proper OOP concepts will reduce the complexity and the entity of the objects are dissociated with other parts of the code. Also, it improves readability and can be easily modified if required.

Also, the OOP concept like inheritance provides the extensibility of code. These concepts are helpful for defining abstract classes, updating previously implemented codes, implementing an application for real-life scenarios.

Abstraction, encapsulation is the fundamental concepts in object-oriented programming. And every programmer implements these concepts for a clean and reusable code. But there are a considerable number of differences between these two concepts, let’s understand them in this article.

At first, let’s have a quick walk through the concepts of abstraction and encapsulation.

Abstraction

Abstraction is a process of hiding unnecessary data and showing only relevant data. Out of an ocean of data, we are only maintaining the transparency of some data to the user. This important concept in object-oriented programming will reduce the complexity of the code and increases the readability.

For example, let’s say we were assigned a task to create an online course enrollment portal, and the data fields available to us are {name, age, current occupation, college name, course name, payment method, sibling’s name, marital status, vehicle number}.

After having a look at the data fields available, we’ll come to understand that some of the fields are not necessary for the course enrollment portal, fields like {sibling’s name, marital status, vehicle number} are not required for course enrollment.

So, we need to be specific and choose only the relevant data. Now the necessary fields are {name, age, current occupation, college name, course name, payment method}, this makes an example of abstraction in OOP because we’ve escorted selected information from whole data.

Now, this new data can also be used for some other applications like course status tracker, course completion record, etc. We can use the same data without any changes.

Many people get often confused about abstraction and abstract class, So are they both related?

An abstract class is different from abstraction, abstract classes/methods are created with an intention to implement them in child class or subclass. Whereas abstraction is simply hiding the data, and showing only the relevant data by using access specifiers like public, protected, private.

Encapsulation

Encapsulation is binding the data members with member variables. This will avoid the direct access of variables, because direct access of variables may violate privacy, and hiding of the implementation will not be possible.

We may have gone through some classic methods in class like set and get, where the set method is used to update or allocate a value to a variable and the get method is used to read or retrieve the value of a variable. Here we can directly access the variables using the object of that class, but if we want to make a variable private then we should use these settings and get methods.

The concept is simple, we’ll make the set and get methods public and the variables are private. So the variables can be accessed only through the public methods outside the class since private objects are not accessible outside class but accessible inside class. This concept of binding or bundling variables with methods is called encapsulation.

Let us have a look at a simple java program to understand this better.

class CourseRegistration{
private String student_name;
private String course_name;
public String getName(){
return student_name;
}
public void setName(String name){
this.student_name=name;
}
public String getCourse(){
return course_name;
}
public void setCourse(String course){
this.course_name=course;
}
}
public class upGrad{
public static void main(String[] args){
CourseRegistration c=new CourseRegistration();
c.setName(“mithun”);
c.setCourse(“Data Science”);
System.out.println(c.getName());
System.out.println(c.getCourse());
}
}

In the above code, we’ve created a class CourseRegistration, where the member variables student name, and course name are private, but we are accessing it in another class using the set name and get name functions. In the main class, we’ve created an object of CourseRegistration type. We are initializing and accessing the member variables using the set and get functions.

Now that we’ve seen the definition and example of abstraction let’s discuss the advantages and differences between abstraction and encapsulation.

Advantages of Abstraction

Privacy of data is maintained since only relevant data is visible to the user.
Reduces the complexity of code and increases readability.
The class which implements the abstraction can be used as a parent class by inheriting them, hence improving reusability, and reducing duplication.

Advantages of Encapsulation

It helps in binding the data members with member functions.
Improves efficiency and user friendly for error analysis.
Provides flexibility to the programmer in controlling the accessibility and transparency of the data.

Difference Between Abstraction and Encapsulation

Definition

Abstraction is hiding the details and implementation of the code.
Encapsulation is hiding the data and controlling the visibility of the code.

Phase

Abstraction is a design level process.
Encapsulation is an implementation level process.

Pivotal Ability

Abstraction is concerned about what a class instance can do, instead of the implementation of the class.
Encapsulation helps in data binding and control over maintaining the transparency of the data.

Use Case

Abstraction is a design level process and it is used to reduce the complexity at the designing stage of a project.
Encapsulation is an implementation level process, and it is used to provide privacy and maintain control over the transparency of data at the implementation stage of a project.

How to Implement

Abstraction can be achieved using class and interfaces in java.
Encapsulation is also implemented using classes and the control over data privacy is obtained by specifying access specifiers like protected, public, private.

Learn Software Development Courses online from the World’s top Universities. Earn Executive PG Programs, Advanced Certificate Programs, or Masters Programs to fast-track your career.

Conclusion

We’ve gone through the importance of OOP concepts, understood the definition of abstraction and encapsulation. Walked through the examples of abstraction, and encapsulation. We also had a look over the advantages of using OOP concepts like abstraction and encapsulation. And finally, we’ve gone through the difference between abstraction and encapsulation.

Now that you are aware of the definition and implementation of abstraction, encapsulation, try implementing them in your code and try reducing the complexity of the code which you are going to write from now on!

If you’re interested to learn more about Java, full-stack development, check out upGrad & IIIT-B’s Executive PG Program in Full-stack Software Development which is designed for working professionals and offers 500+ hours of rigorous training, 9+ projects, and assignments, IIIT-B Alumni status, practical hands-on capstone projects & job assistance with top firms.

What is abstraction in object-oriented programming?

Abstraction in object-oriented programming is a technique to represent the high-level information about a problem by building an object. Abstraction is implemented with the help of the interface and the implementation of the interface is done using the actual code. Abstraction is implemented where the concrete details are hidden from the consuming modules by providing it with a different interface. Abstraction is implemented to hide the implementation details of the low-level details. It is also used to hide the complex details and provide the simpler interface to the user.

How do classes and objects work in programming?

Classes and objects are the two main concepts employed in all object-oriented programming languages. Every class contains a set of variables and methods that it can use and manipulate. In an object-oriented programming language, all the objects in a program have a specific type and the variables and methods of an object can only be manipulated by methods of the same type. In most object-oriented languages, the class is used to create an object and vice versa. An object-oriented program is made up of objects, procedures, and data types. Everything in an object-oriented program, including data and code, is an object.

What are the differences between encapsulation and abstraction?

Abstraction is a method of removing the unnecessary details in the code and focusing on the relevant parts. For example, instead of writing a function that multiplies two numbers, we can write a function “multiply” and use it to multiply any number with any number. Abstraction is a way of representing some specific data. Encapsulation is a way of hiding the complexity of something and exposing only the parts you wish to expose. For example, if you have a class that has one or more private fields that you use to store the data, then you are in encapsulation. The class contains the data and has methods that expose the public data.

Want to share this article?

Land on Your Dream Job

Apply Now for Executive PG Program in Full Stack Development