Abstraction Vs Encapsulation

Java is an object-oriented programming language and it follows OOPs concepts. The OOPs concepts include classes, objects, polymorphism, inheritance. There are two other features of OOPs i.e. abstraction and encapsulation. They both seem very similar but totally different in concept and implementation. The major difference between abstraction and encapsulation is that abstraction hides the code complexity while encapsulation hides the internal working from the outside world. In this section, we will discuss abstraction and encapsulation and the differences between abstraction and encapsulation in Java.

Abstraction

It is a feature of OOPs. It is used to hide the unnecessary information or data from the user but shows the essential data that is useful for the user. It can be achieved by using the interface and the abstract class. In interfaces, only the methods are exposed to the end-user. The best example of abstraction is a TV remote. The user only interacts with the outer interface that is nothing but keys. The user only knows which key to press for what function.

Let's understand the abstraction through a Java program.

//abstract class
abstract class Shape 
{
//abstract method
//note that we have not implemented the functionality of the method
public abstract void draw();
}
class Circle extends Shape
{
//implementing functionality of the abstract method
public void draw() 
{
System.out.println("Circle!");
}
}
//main class 
public class Test 
{
public static void main(String[] args) 
{
Shape circle = new Circle();
//invoking abstract method draw()
circle.draw();
}
}

Encapsulation

It is also a feature of OOP. It is used to bind up the data into a single unit called class. It provides the mechanism which is known as data hiding. It is an important feature of OOPs. It prevents to access data members from the outside of the class. It is also necessary from the security point of view.

Let's understand the abstraction through a Java program.

EncapsulationDemo.java

//A Java class to test the encapsulated class Account  
public class EncapsulationDemo
{  
public static void main(String[] args) 
{  
//creating instance of Account class  
Account acc=new Account();  
//setting values through setter methods  
acc.setAcc_no(7560504000L);  
acc.setName("Mark Dennis");  
acc.setEmail("md123@gmail.com");  
acc.setAmount(500000f);  
//getting values through getter methods  
System.out.println(acc.getAcc_no()+" "+acc.getName()+" "+acc.getEmail()+" "+acc.getAmount());  
}  
} 

Account.java

class Customer
{  
//private data members  
private long cstmr_id;  
private String cstmr_name, cstmr_email;  
private float amount;  
//public getter and setter methods  
public long getAcc_no() 
{  
return acc_no;  
}  
public void setAcc_no(long acc_no) 
{  
this.acc_no = acc_no;  
}  
public String getName() 
{  
return name;  
}  
public void setName(String name) 
{  
this.name = name;  
}  
public String getEmail() 
{  
return email;  
}  
public void setEmail(String email) 
{  
this.email = email;  
}  
public float getAmount() 
{  
return amount;  
}  
public void setAmount(float amount) 
{  
this.amount = amount;  
}    
}  

Difference Between Abstraction and Encapsulation

Abstraction	Encapsulation
Abstraction is a feature of OOPs that hides the unnecessary detail but shows the essential information.	Encapsulation is also a feature of OOPs. It hides the code and data into a single entity or unit so that the data can be protected from the outside world.
It solves an issue at the design level.	Encapsulation solves an issue at implementation level.
It focuses on the external lookout.	It focuses on internal working.
It can be implemented using abstract classes and interfaces.	It can be implemented by using the access modifiers (private, public, protected).
It is the process of gaining information.	It is the process of containing the information.
In abstraction, we use abstract classes and interfaces to hide the code complexities.	We use the getters and setters methods to hide the data.
The objects are encapsulated that helps to perform abstraction.	The object need not to abstract that result in encapsulation.