B3.1.5 Explaining and Applying the Concepts of Encapsulation and Information Hiding in OOP Notes

The Principles of Encapsulation and Information Hiding

1. Encapsulation is the practice of bundling (or encapsulating) data and methods that operate on that data within a single unit, typically a class.
2. This ensures that the internal workings of the class are hidden from the outside world.
3. Information Hiding is a related concept that focuses on restricting access to certain parts of an object's data or implementation details.
4. This is achieved by using access modifiers to control which parts of a class are visible to other parts of the program.

Applying Access Modifiers: Private and Public

Access modifiers are keywords that define the visibility of class members (variables and methods).

The most common access modifiers are:

1. Private:
   1. Members declared as private are accessible only within the class itself.
   2. This is the default access level for instance variables in encapsulated classes.
2. Public:
   1. Members declared as public are accessible from any other class.
   2. This is typically used for methods that need to be called from outside the class.

Controlling Access to Class Members

Encapsulation is achieved by controlling access to class members through a combination of private variables and public methods.

This allows you to:

1. Protect Data Integrity: By restricting direct access to variables, you can ensure that data is modified only through controlled methods.
2. Simplify Maintenance: Changes to the internal implementation of a class do not affect other parts of the program, as long as the public interface remains consistent.
3. Enhance Security: Sensitive data and operations are hidden from external access, reducing the risk of unintended modifications.

The Importance of Limiting Access

Limiting access to class members is crucial for maintaining the integrity and security of an object's state.

Here are some key reasons why this is important:

1. Preventing Inconsistent States: By controlling how data is modified, you can ensure that an object remains in a valid state.
2. Reducing Coupling: Encapsulation reduces dependencies between classes, making the codebase more modular and easier to maintain.
3. Facilitating Code Reuse: Encapsulated classes can be reused in different contexts without exposing their internal details.

public class BankAccount {
    // Private variable (encapsulated data)
    private double balance;

    // Constructor
    public BankAccount(double initialBalance) {
        if (initialBalance >= 0) {
            balance = initialBalance;
        }
    }

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

    // Mutator (Deposit)
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    // Mutator (Withdraw with validation)
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        }
    }
}