Undertanding Encapsulation in Java

Java Encapsulation

Encapsulation is a fundamental concept in object-oriented programming (OOP) and is critical for developing clean, efficient, and maintainable Java code. It refers to the combination of data (variables) and methods (functions) for manipulating data into a single entity known as a class. This approach blocks direct access to parts of the object's components, improving security, simplifying the software, and making it easier to maintain.

What is Encapsulation in Java

Encapsulation in Java is achieved by making class fields (data members) private but offering public getter and setter methods for accessing and updating these fields. This restriction over data access ensures that data is only modified via well-defined interfaces, protecting the object's internal state.

Key Points of Encapsulation:

• Data Hiding: It limits the visibility of internal object states and only enables access to public methods.
• Controlled Access: The usage of getter and setter methods allows for controlled access to variables.
• Flexibility: The internal representation of the data can change without affecting the external code that relies on it.

How Encapsulation Works in Java?

Let us break down encapsulation with an example. Assume we have a student class. Without encapsulation, the internal fields would be visible to anyone, perhaps leading to misuse or unwanted changes.

Example Without Encapsulation:

class Student
{
    String name;
    int age;
}

Example with Encapsulation:

class Employee{
    private String name;
    private int age;
    // Getter method for name
    public String getName() {
        return name;
    }
    // Setter method for name
    public void setName(String name) {
        this.name = name;
    }
    // Getter method for age
    public int getAge() {
        return age;
    }
    // Setter method for age
    public void setAge(int age) {
        if(age > 0) {
            this.age = age;
        } else {
            System.out.println("Age cannot be negative");
        }
    }
}

Explanation

Real-World Example of Encapsulation in Java

class BankAccount {
    private double balance;

    // Getter for balance
    public double getBalance() {
        return balance;
    }

    // Deposit method with validation
    public void deposit(double amount) {
        if(amount > 0) {
            balance += amount;
        } else {
            System.out.println("Deposit amount must be positive");
        }
    }

    // Withdraw method with validation
    public void withdraw(double amount) {
        if(amount > 0 && amount <= balance) {
            balance -= amount;
        } else {
            System.out.println("Invalid withdrawal amount");
        }
    }
}

Explanation