Encapsulation in Java

Need for Encapsulation in Java

• Encapsulation enhances data security by restricting access to class fields and methods.
• It promotes modularity, allowing a class to be modified without affecting other parts of the program.
• Encapsulation aids in the maintainability of code by organizing data and related methods together.
• It allows for controlled access to class properties through getter and setter methods.
• Encapsulation supports the concept of data hiding, protecting sensitive data from unauthorized access or modification.
• It improves code reusability by creating self-contained classes that can be easily integrated into different programs.

Implementation of Java Encapsulation

Encapsulation in Java is implemented by making class variables private and providing public getter and setter methods to access and update these variables safely.

Java Encapsulation Example

• Java

Java

public class Person {
    // Private variables (encapsulated data)
    private String name;
    private int age;

    // Getter for name
    public String getName() {
        return name;
    }

    // Setter for name
    public void setName(String name) {
        this.name = name;
    }

    // Getter for age
    public int getAge() {
        return age;
    }

    // Setter for age with validation
    public void setAge(int age) {
        if (age > 0 && age < 120) {
            this.age = age;
        } else {
            System.out.println("Invalid age!");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Person p = new Person();

        // Setting values using setters
        p.setName("Rahul");
        p.setAge(25);

        // Getting values using getters
        System.out.println("Name: " + p.getName());
        System.out.println("Age: " + p.getAge());

        // Trying to set invalid age
        p.setAge(-5); 
    }
}

You can also try this code with Online Java Compiler

Run Code

Output:

Name: Rahul
Age: 25
Invalid age!

Data Encapsulation Basics

In this example, name and age are declared private to hide the data from direct access outside the class. Public getter and setter methods provide controlled access, ensuring that the internal state of the object is protected.

Encapsulating Data with Validation Checks

The setAge method includes a validation check to allow only realistic age values (between 1 and 119). This prevents invalid data from corrupting the object’s state, illustrating how encapsulation helps maintain data integrity.

Encapsulating Multiple Data Fields in Java

Multiple fields like name and age can be encapsulated within the same class using the same principles: private variables and public getters/setters. This approach keeps related data bundled and secure while offering flexible access.

Data Hiding vs. Encapsulation in Java

Getter and Setter Methods

Getter and Setter methods in Java are used to access and modify the private fields of a class. They provide a controlled way to interact with class attributes while ensuring that encapsulation is maintained.

1. Getter Method: A getter method retrieves the value of a private field. It typically follows the naming convention of get followed by the field name, capitalized (e.g., getName for a field name).
2. Setter Method: A setter method updates the value of a private field. It usually follows the naming convention of set followed by the field name, capitalized (e.g., setName for a field name).

Now let's see an example of encapsulation.

Advantages of Encapsulation

• Data Hiding: The user will be unaware of the class's internal implementation. The user will be unable to observe how the class keeps variables values. Only the user will be aware that the values are supplied to a setter method and that variables are set to that value.
• Increased Flexibility: Depending on our needs, we can make the class's variables read-only or write-only. If we want the variables to be read-only, we must remove the setter methods like set_FunctionNmae(); if we want the variables to be write-only, we must remove the get methods like get_FunctionName().
• Reusability: Encapsulation also promotes reusability and makes it simple to adapt to changing requirements.
• Testing code is easy: Unit testing is simple with encapsulated code.

You can also find the output of this java compiler code here.

Disadvantages of Encapsulation in Java

• Increased Code Complexity: Encapsulation often requires writing additional code, such as getter and setter methods, which can make the codebase more complex and lengthy.
• Performance Overhead: The use of getter and setter methods can introduce a small performance overhead, especially in scenarios where these methods are called frequently.
• Limited Accessibility: While encapsulation enhances security, it can also limit access to essential data or methods, which might require more effort to work around, especially in debugging or testing phases.
• Potential Overhead in Maintenance: Managing a large number of encapsulated classes with multiple private fields and associated methods can become challenging, especially in large-scale projects where maintaining consistency becomes crucial.
• Reduced Flexibility: Encapsulation can sometimes reduce flexibility by preventing direct access to data, which may require additional methods or modifications to work with the encapsulated data effectively.

Frequently Asked Questions

What is encapsulation in OOP?

Encapsulation is an OOP principle that bundles data and methods, restricting direct access to an object's internal state to protect and control it.

What are the three types of encapsulation?

The three types are: data encapsulation (hiding data), procedural encapsulation (hiding methods), and control encapsulation (controlling access via interfaces).

Which layer uses encapsulation?

Encapsulation is primarily used in the object layer of software design to hide internal object details and expose only necessary interfaces.

What are the methods of encapsulation?

Encapsulation is achieved using access modifiers (private, protected, public), getter and setter methods, and interfaces to control data visibility and access.

Conclusion

In this article, we have extensively discussed Encapsulation in Java. Encapsulation in Java is a powerful object-oriented programming concept that plays a crucial role in building secure, maintainable, and modular software. By bundling data and methods within a class and controlling access to the data through public methods, encapsulation enhances data security, reduces code complexity for users, and supports the principle of data hiding. 

Explore more related articles: 

• Java Tokens
• Java Verify
• Why is Java Platform Independent
• Super Keyword In Java
• Multiple Inheritance in Java
• Duck Number in Java.
• Type Conversion in Java