encapsulation in java

encapsulation in java

Encapsulation is a fundamental concept in object-oriented programming (OOP) that refers to the bundling of data (attributes) and methods (functions or behaviors) that operate on the data into a single unit, usually called a class. Encapsulation helps protect the internal state of an object from unintended or harmful interference and misuse by restricting direct access to some of its components. Instead, the object’s data is accessed and modified through well-defined interfaces (methods).

encapsulation in java

Key Aspects of Encapsulation:

  • 1. Data Hiding:
    • The internal state of an object is hidden from the outside world. This is achieved by declaring the object’s attributes as private.
    • Direct access to private attributes is restricted, ensuring that data is not exposed directly and can only be accessed through public methods.
  • 2. Public Methods:
    • Public methods (getters and setters) provide controlled access to the object’s data.
    • Getters allow external code to retrieve the value of a private attribute.
    • Setters allow external code to modify the value of a private attribute, often with validation logic to ensure data integrity.
  • 3. Improved Maintainability:
    • Encapsulation leads to a modular code structure, where the implementation details of a class are hidden. This makes the code more maintainable and flexible to changes.
    • Changes to the internal implementation of a class do not affect external code that interacts with the class through its public methods.
  • 4. Enhanced Security:
    • By restricting access to the internal state of an object, encapsulation helps safeguard the data from accidental or malicious modifications.
    • Validation logic within setters ensures that only valid data is accepted, enhancing the robustness of the code.

Example of Encapsulation in Java:

Here is a simple example to illustrate encapsulation:

Syntax
```java
public class BankAccount {
    // Private attributes
    private String accountNumber;
    private double balance;

    // Constructor to initialize the account
    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }

    // Public getter for accountNumber
    public String getAccountNumber() {
        return accountNumber;
    }

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

    // Public method to deposit money
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    // Public method to withdraw money
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // Create a new BankAccount object
        BankAccount account = new BankAccount("123456789", 1000.0);

        // Access and modify the account balance using public methods
        account.deposit(500.0);
        account.withdraw(200.0);

        // Print the account details
        System.out.println("Account Number: " + account.getAccountNumber());
        System.out.println("Balance: " + account.getBalance());
    }
}
```

Explanation:

  • Private Attributes: The `accountNumber` and `balance` attributes are declared as private, hiding them from direct access by external code.
  • Public Methods: The class provides public methods (`getAccountNumber`, `getBalance`, `deposit`, and `withdraw`) to interact with the object’s data. These methods ensure controlled access and modification of the internal state.
  • Data Integrity: The `deposit` and `withdraw` methods include validation logic to ensure that only valid transactions are processed, maintaining the integrity of the account’s balance.

Encapsulation ensures that the internal state of the `BankAccount` object is protected and can only be modified in a controlled manner through the public methods provided by the class. This promotes a robust and maintainable code structure.