Encapsulation in Java

What is Encapsulation in Java?

Encapsulation is one of the core principles of object-oriented programming (OOP). It refers to the practice of wrapping data (variables) and code (methods) together into a single unit, typically a class, while restricting direct access to some of the object's components. This helps protect the data from unintended modifications and provides control over how data is accessed or modified.

Why Use Encapsulation?

Encapsulation helps in:

• Protecting data by making variables private.
• Controlling access via public getter and setter methods.
• Improving modularity and maintainability.
• Hiding the internal implementation details from outside code.

How to Implement Encapsulation in Java

In Java, encapsulation is achieved by:

• Declaring the variables of a class as private.
• Providing public getter and setter methods to access and update the variables.

public class Person {
    private String name;  // private variable
    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;  // Validate input before setting
        }
    }
}

    

Using the Encapsulated Class

public class Main {
    public static void main(String[] args) {
        Person p = new Person();
        p.setName("Alice");
        p.setAge(25);

        System.out.println("Name: " + p.getName());
        System.out.println("Age: " + p.getAge());
    }
}

    

Benefits of Encapsulation

• Improved Security: Sensitive data is hidden from unauthorized access.
• Controlled Access: Validation can be done inside setters to ensure data integrity.
• Flexibility: Internal implementation can be changed without affecting outside code.
• Reusability: Encapsulated classes are easier to reuse and maintain.

Encapsulation vs Abstraction

Although related, encapsulation and abstraction are different concepts. Encapsulation focuses on restricting access to the inner workings of a class, while abstraction hides complex implementation details and shows only the necessary features to the user.

Conclusion

Encapsulation in Java is essential for building secure and maintainable applications. By restricting direct access to class members and exposing only necessary parts through getters and setters, encapsulation enforces data protection and helps developers write cleaner, modular code. Embracing encapsulation leads to robust and flexible Java programs.