# Encapsulation

Encapsulation is one of the fundamental principles of object-oriented programming (OOP) and is often described as the bundling of data (attributes or properties) and methods (functions) that operate on that data into a single unit called a class. It also involves controlling the access to the data by restricting direct access to the internal state of an object. Encapsulation helps in achieving data abstraction, data hiding, and code organization, leading to more maintainable and reusable code. Here's a detailed explanation of encapsulation:

1. **Data and Methods Together**:
   * In an encapsulated class, data (attributes or member variables) and methods (member functions) that operate on that data are grouped together as a cohesive unit.
   * This means that the class defines both the data structure and the operations that can be performed on that data.
2. **Access Control**:
   * Encapsulation involves controlling access to the internal data of an object.
   * Data members of a class can have different access modifiers (public, private, and protected) that determine who can access them:
     * **Public members**: These members are accessible from anywhere, even outside the class. They form the interface to the outside world.
     * **Private members**: These members are only accessible within the class itself. They are hidden from external access.
     * **Protected members**: These members are similar to private members but are accessible in derived classes as well.
3. **Data Hiding**:
   * One of the key benefits of encapsulation is data hiding, which means that the internal details of how data is stored and manipulated are hidden from the outside world.
   * Private data members cannot be accessed directly from outside the class, ensuring that the internal state remains consistent and protected.
4. **Information Hiding**:
   * Encapsulation allows you to hide the complexity of the implementation details from users of the class.
   * Users of the class interact with the public interface provided by the class, rather than needing to know how the class's methods are implemented.
5. **Modularity and Reusability**:
   * Encapsulation promotes modularity by encapsulating related data and functions into a single unit.
   * This modularity makes it easier to understand, modify, and maintain code.
   * Encapsulated classes can also be reused in different parts of the program or in other programs, promoting code reusability.
6.  **Encapsulation Example**:

    * Here's a simple example in C++ to illustrate encapsulation:



    ```cpp
    class BankAccount {
    private:
        double balance; // Private data member

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

        // Public member function to check balance
        double GetBalance() {
            return balance;
        }
    };
    ```



    * In this example, the `balance` data member is private, and the `Deposit` and `GetBalance` methods provide controlled access to this data. Users of the `BankAccount` class can deposit money and check their balance without knowing the internal details of how `balance` is managed.

In summary, encapsulation is a fundamental concept in object-oriented programming that combines data and methods into a single unit (class) while controlling access to the internal data. It promotes information hiding, data protection, code organization, and modularity, making it a crucial principle for building maintainable and robust software systems.
