Understanding Encapsulation in Programming

What is Encapsulation?

Encapsulation is one of the core concepts in object-oriented programming. It refers to the bundling of data (variables) and methods (functions) that operate on that data into a single unit — a class. Moreover, encapsulation allows for restricting direct access to some of an object’s components, which means hiding the internal state and requiring all interaction to happen through methods.

Why is Encapsulation Important?

• Improves code modularity.
• Enhances security by hiding internal state.
• Makes maintenance and debugging easier.
• Prevents external code from corrupting object state accidentally.

Analogy

Think of a capsule pill. The outer shell hides the ingredients inside. Similarly, in programming, encapsulation hides the inner workings of an object and only exposes what is necessary.

Example 1: Encapsulating Data with Access Methods

Let’s define a class called BankAccount. We’ll keep the balance private and only allow deposits and withdrawals through defined methods.

CLASS BankAccount:
    PRIVATE balance

    METHOD constructor(initialAmount):
        SET balance = initialAmount

    METHOD deposit(amount):
        IF amount > 0 THEN
            balance = balance + amount

    METHOD withdraw(amount):
        IF amount <= balance THEN
            balance = balance - amount

    METHOD getBalance():
        RETURN balance

Balance cannot be accessed directly.
Use getBalance() to retrieve current balance.

Explanation:

In the above example:

• The balance variable is marked as PRIVATE, meaning it can't be accessed from outside the class.
• To interact with balance, we provide public methods like deposit(), withdraw(), and getBalance().
• This protects the internal state of the object from unintended changes.

Beginner's Question:

Q: Why not just make the balance variable public and update it directly?

A: If balance is public, anyone can set it to any value, including a negative number. By using methods, we can add rules and checks (like not allowing withdrawals beyond the available amount).

Example 2: Encapsulation in a Student Record

Now let’s create a Student class with encapsulated data like name and grade.

CLASS Student:
    PRIVATE name
    PRIVATE grade

    METHOD constructor(studentName, studentGrade):
        name = studentName
        IF studentGrade >= 0 AND studentGrade <= 100 THEN
            grade = studentGrade
        ELSE
            grade = 0

    METHOD setGrade(newGrade):
        IF newGrade >= 0 AND newGrade <= 100 THEN
            grade = newGrade

    METHOD getGrade():
        RETURN grade

Student grade is validated before being updated.

Explanation:

Here we encapsulated grade so that it is only changed through setGrade(). This ensures that no invalid grades can be set (like -10 or 120).

Another Question:

Q: Can we still read the values if they are private?

A: Yes, by providing public methods like getGrade() or getBalance(), we can safely expose values without making them publicly modifiable.

Key Takeaways:

• Encapsulation protects data from unintended interference.
• Use accessors (getters) and mutators (setters) to control how variables are accessed or changed.
• Encapsulation makes programs more reliable and secure.

Try It Yourself

Create a Car class with encapsulated data for speed. Add methods to increase or decrease speed, ensuring it doesn’t go below 0 or above a defined max.

Q: What problems might arise if you make all data public?

A: Think through edge cases — wrong data formats, invalid ranges, conflicting values — and you’ll quickly see why encapsulation is a good practice.