Introduction on 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 the wrapping up of data into a single unit in order to prevent access to it from the outside world. Since the data is hidden from the other classes, this process is also known as Data-hiding. Let us consider the working of a bulb as an example. We do not know the actual working behind the bulb even if we are using it. 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 in order 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 it is needed.
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 of the examples for the fully encapsulated class as all the data members in the class are private.
4.8 (10,660 ratings)
View Course
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 main 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:
In the above program, the class Employee is encapsulated 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, 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, here also, we are using private variables. The difference is that we are not using the set method in order 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:
In the above example, we are not using the get method to achieve write only class. i.e. the variables can’t be changed or retrieve here. Since it is not possible to get the values, we are using 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 to get, set to access the variables. The main advantages of Encapsulation include Flexibility, Data hiding, easiness in testing, and reusability.
Recommended Articles
This has been a guide to Encapsulation in Java. Here we discuss how does encapsulation works, examples of Java Encapsulation with codes and output. You can also go through our given articles to learn more-
