Introduction to Encapsulation in Java
Encapsulation is one of the four basic Object Oriented Programming Concepts in Java. The main idea behind this is the hiding of implementation details from users. In other words, Encapsulation is wrapping up data into a single unit to prevent access to it from the outside world. Since the data is hidden from the other classes, this process is known as Data-hiding. Let us consider the working of a bulb as an example. Even if we use it, we do not know if it’s working behind the bulb. But in the case of Java Encapsulation, it is possible to access the data using modifiers. Let us look into it in the next section.
How Does Encapsulation work in java?
Encapsulation works in Java by
- Declaring the attributes or variables in class as private
For Example, we are creating a class Employee. The variables need to be set as private, as shown below.
private String EmpName;
private int EmpID;
private int EmpSal;- Creating public methods in class to get and set the attributes or variables.
Following is the get method and set method for the different private variables in the class Employee.
Code:
public int getEmpSal()
{
return EmpSal;
}public String getEmpName()
{
return EmpName;
}
public int getEmpID()
{
return EmpID;
}
public void setEmpSal( int EmpSal)
{
this.EmpSal = EmpSal;
}
public void setEmpName(String EmpName)
{
this.EmpName = EmpName;
}
public void setEmpID( int EmpID)
{
this.EmpID = EmpID;
}Using these methods, it is possible to make the class write-only or read-only, i.e., We can skip these methods if needed.
Advantages of Encapsulation in Java
The following are some of the Advantages of Encapsulation.
- Simplicity in Application
- Ability to reuse or modify the code based on the requirements
- Limits the accessibility of data
- Easiness in unit testing as the code is encapsulated
Java Bean Class is one example of a fully encapsulated class, as all the data members in the class are private.
Examples of Java Encapsulation
Let us see an example of Encapsulation with both getter and setter methods. For that, create 2 classes-one with the primary method and the other with getting and set methods.
Example #1
Employee.java
Code:
//Java program for Encapsulation with both read and write
public class Employee {
//private variables which can be accessed by public methods of the class
private String EmpName;
private int EmpID;
private int EmpSal;
// get method to access the private integer variable EmpSal
public int getEmpSal()
{
return EmpSal;
}
// get method to access the private string variable EmpName
public String getEmpName()
{
return EmpName;
}
// get method to access the private integer variable EmpID
public int getEmpID()
{
return EmpID;
}
// set method to access the private integer variable EmpSal
public void setEmpSal( int EmpSal)
{
this.EmpSal = EmpSal;
}
// set method to access the private string variable EmpName
public void setEmpName(String EmpName)
{
this.EmpName = EmpName;
}
// set method to access the private integer variable EmpID
public void setEmpID( int EmpID)
{
this.EmpID = EmpID;
}
}- EmployeeEncaps.java
Code:
public class EmployeeEncaps {
public static void main(String[] args) {
Employee EmpObj= new Employee(); //object of the class Employee
//passing the values to the methods using object
EmpObj.setEmpName("Anna");
EmpObj.setEmpSal(30000);
EmpObj.setEmpID(670311);
// Printing values of the variables
System.out.println("Employee's Name: " + EmpObj.getEmpName());
System.out.println("Employee's ID: " + EmpObj.getEmpID());
System.out.println("Employee's Salary: " + EmpObj.getEmpSal());
}
}Output:
The class Employee is encapsulated in the above program as the variables are private. It is possible to read and write the implementation since it has got and set methods. The private variables such as EmpName, EmpSal, and EmpID are accessed using these methods and displayed by calling the methods using the object.
Now, let us see how Encapsulation works with a Read-only class.
Example #2
- Employee.java
Code:
//Java program for Encapsulation with read permission
public class Employee {
//private variables which can be accessed by public methods of the class
private String EmpName = "Adam";
private int EmpID = 670388;
private int EmpSal = 35000;
// get method to access the private integer variable EmpSal
public int getEmpSal()
{return EmpSal;
}// get method to access the private string variable EmpName
public String getEmpName()
{
return EmpName;
}
// get method to access the private integer variable EmpID
public int getEmpID()
{
return EmpID;
}
}- EmployeeEncaps.java
Code:
public class EmployeeEncaps {
public static void main(String[] args) {
Employee EmpObj= new Employee(); //object of the class Employee
// Printing values of the variables
System.out.println("Employee's Name: " + EmpObj.getEmpName());
System.out.println("Employee's ID: " + EmpObj.getEmpID());
System.out.println("Employee's Salary: " + EmpObj.getEmpSal());
}
}Output:
Similar to the first example, we are also using private variables. The difference is that we are not using the set method to set values for the private variables in the class. Instead, we directly assign the value to the variables.
Now, we can move on to a write-only class.
Example #3
- Employee.java
Code:
//Java program for Encapsulation with write permission
public class Employee {
//private variables which can be accessed by public methods of the class
private String EmpName;
private int EmpID;
private int EmpSal;
// set method to access the private integer variable EmpSal
public void setEmpSal( int EmpSal)
{
this.EmpSal = EmpSal;
//for sample output
System.out.println("Employee's Salary: " + EmpSal);
}
// set method to access the private string variable EmpName
public void setEmpName(String EmpName)
{
this.EmpName = EmpName;
//for sample output
System.out.println("Employee's Name: " + EmpName);
}// set method to access the private integer variable EmpID
public void setEmpID( int EmpID)
{
this.EmpID = EmpID;
//for sample output
System.out.println("Employee's ID: " + EmpID);
}
}- EmployeeEncaps.java
Code:
public class EmployeeEncaps {
public static void main(String[] args) {
Employee EmpObj= new Employee(); //object of the class Employee
//passing the values to the methods using object
EmpObj.setEmpName("Iza");
EmpObj.setEmpID(670472);
EmpObj.setEmpSal(48000);
}
}Output:
We are not using the get method to achieve a write-only class in the above example. i.e., the variables can’t be changed or retrieved here. Since it is impossible to get the values, we use print inside the set method for sample output.
Conclusion
Encapsulation is an OOP concept where data will be wrapped, hiding all the implementation details. It can be achieved by using private variables and methods such as getting and setting to access the variables. The main advantages of Encapsulation include Flexibility, Data hiding, easiness in testing, and reusability.
Recommended Articles
This is a guide to Encapsulation in Java. Here we have discussed how encapsulation works, and examples of Java Encapsulation with codes and output. You can also go through our given articles to learn more-
