4.4. Encapsulation in Java

Encapsulation is the concept of restricting access to certain details of an object and providing access through well-defined methods (getters and setters). This helps in protecting the object's data and ensuring it is used correctly.

Encapsulation in Java is a fundamental concept that protects an object's data by restricting direct access to its internal details. Instead of allowing everything to interact with the data directly, encapsulation uses methods known as getters (to retrieve data) and setters (to update data). This controlled approach safeguards the integrity of the data, making it less susceptible to unwanted changes or misuse. Think of it as putting important documents in a locked drawer; only those with the key (the methods) can access or change the documents.

Imagine a bank account as an object. The balance cannot be changed arbitrarily by anyone. Instead, there are set procedures (methods) to deposit or withdraw money. This way, the bank ensures that only valid transactions affect the balance.

Private Variables: Data members (variables) of a class should be declared as private to prevent direct access from outside the class. Public Methods: Public getter and setter methods are provided to access and update the private variables.

In Java, using encapsulation starts with declaring class variables as private. This means that these variables cannot be accessed directly outside of the class. To allow controlled access, public methods are created. Getters return the value of private variables, while setters allow you to set a value for them. This practice is beneficial because it allows us to add additional logic to these methods later without affecting how other parts of the code interact with our object.

Think of a TV remote. The buttons (methods) on the remote allow you to change the channels or volume, but you can't directly access the internal mechanisms of the TV (private variables). The remote controls the interaction without exposing the complexity of how the TV works.

Example:

class Person {
private String name;
private int age;
// Getter method
public String getName() {
return name;
}
// Setter method
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Main {
public static void main(String[] args) {
Person person = new Person();
person.setName("John");
person.setAge(25);
System.out.println("Name: " + person.getName());
System.out.println("Age: " + person.getAge());
}
}

In this example, we define a class Person with private variables name and age. By providing public getter and setter methods, we're allowing controlled access to these variables. The setName method updates the name, and the getName method retrieves it. This demonstrates how encapsulation protects the data while still allowing interaction through predetermined methods.

Consider a university application process where students fill in personal details. The application form (the public interface) allows students to submit information, but the actual handling of that data (the private variables) is managed by the admissions office. The students can't directly access the database; they must go through official channels (the getter and setter methods) to ensure everything is correct and secure.

--