Encapsulation & Abstraction

These two concepts are the "security guards" of OOP. They help you build complex systems that are easy to use but hard to break.

1. Encapsulation (Data Hiding)

Encapsulation is the process of grouping data and the methods that act on that data into a single unit (a class) and restricting access to the inner workings.

• How? We make variables private and provide public functions (called Getters and Setters) to interact with them.

• Why? It prevents outside code from setting invalid values (like setting a human's age to -500).

2. Abstraction (Complexity Hiding)

Abstraction means showing only the essential features of an object and hiding the complex implementation details.

• The Remote Control Analogy: You know that pressing the "Power" button turns on the TV. You don't need to know how the internal circuitry works to use it. In code, we use simple function calls to hide complex logic.

Code Example: Secure Bank Account

This program prevents a user from directly changing their balance without going through a validation check.

#include <iostream>
#include <string>
using namespace std;

class BankAccount {
private:
    // Encapsulation: These are hidden from the outside world
    double balance;
    string pin;

public:
    // Constructor
    BankAccount(double initialBalance, string initialPin) {
        balance = initialBalance;
        pin = initialPin;
    }

    // Setter (with logic check)
    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            cout << "Deposited: $" << amount << endl;
        } else {
            cout << "Invalid deposit amount!" << endl;
        }
    }

    // Getter (Abstraction: User just sees the total, not the calculation)
    void showBalance() {
        cout << "Current Balance: $" << balance << endl;
    }
};

int main() {
    BankAccount myAccount(1000.0, "1234");

    // myAccount.balance = 5000000; // ERROR! Private member.
    
    myAccount.deposit(500.0);   // Public way to interact safely
    myAccount.showBalance();    // Abstraction in action

    return 0;
}

Difference at a Glance

• Encapsulation: Focuses on Security. (Wraps data to keep it safe).

• Abstraction: Focuses on Simplicity. (Hides details to make code easier to use).