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.
Encapsulation works in Java by
Start Your Free Software Development Course
Web development, programming languages, Software testing & others
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;
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.
The following are some of the Advantages of Encapsulation.
Java Bean Class is one example of a fully encapsulated class, as all the data members in the class are private.
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.
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; } }
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.
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; } }
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.
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); } }
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.
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.
The above is the detailed content of Encapsulation in Java. For more information, please follow other related articles on the PHP Chinese website!