encapsulation in java

Encapsulation in Java refers to the principle of bundling data (attributes) and methods (behaviors) that operate on the data into a single unit, known as a class. Encapsulation helps in hiding the internal state of an object and only exposing the necessary functionalities to the outside world. Here’s how encapsulation is achieved in Java:

1. Declare Data Members as Private:

• Class attributes (fields) should be declared as private to prevent direct access from outside the class.

2. Provide Accessor (Getter) and Mutator (Setter) Methods:

• Accessor methods (getters) are public methods used to retrieve the values of private fields.
• Mutator methods (setters) are public methods used to modify the values of private fields.

3. Controlled Access to Data:

• By providing only getters and setters, you can control how data is accessed and modified from outside the class.
• This allows you to enforce validation logic, perform error checking, and maintain the integrity of the object’s state.

4. Hide Implementation Details:

• Encapsulation allows you to hide the internal implementation details of a class from its users.
• Users interact with objects through a well-defined interface (public methods), without needing to know the internal workings of the class.

5. Prevent Direct Modification of Data:

• By encapsulating data and providing controlled access through methods, you can prevent direct modification of data from outside the class, reducing the risk of unintended side effects.

6. Improve Maintainability and Flexibility:

• Encapsulation promotes modular and reusable code by separating concerns and providing a clear interface for interacting with objects.
• Changes to the internal implementation of a class can be made without affecting its users as long as the public interface remains unchanged.

Here’s a simple example demonstrating encapsulation in Java:

```java
public class EncapsulationExample {
    private int data;

    // Getter method to retrieve the value of 'data'
    public int getData() {
        return data;
    }

    // Setter method to modify the value of 'data'
    public void setData(int newData) {
        // Perform validation or other logic if needed
        data = newData;
    }

    public static void main(String[] args) {
        EncapsulationExample obj = new EncapsulationExample();

        // Accessing and modifying 'data' using getter and setter
        obj.setData(10);
        int value = obj.getData();
        System.out.println("Data value: " + value); // Output: Data value: 10
    }
}
```

In this example, the `data` field is declared as private, and its value is accessed and modified using getter and setter methods (`getData()` and `setData()`). This ensures that the internal state of the `EncapsulationExample` class is encapsulated and can only be accessed or modified through the defined public interface.