Encapsulation

Encapsulation is a fundamental principle of object-oriented programming (OOP) that binds together data (attributes) and the methods that operate on that data into a single unit, a class. This binding creates a protective shield that prevents data from being accessed by the code outside this shield.

Key Concepts:

• Data hiding: Encapsulation hides the internal representation or state of an object from the outside world.
• Access control: Using modifiers like public, private, and protected to control access to class members.
• Information hiding: Protecting sensitive data from unauthorized access.

Example:

Python

class BankAccount:
    def __init__(self, initial_balance):
        self.__balance = initial_balance  # Private attribute

    def deposit(self, amount):
        self.__balance += amount
        print(f"Deposited {amount}. New balance: {self.__balance}")

    def withdraw(self, amount):
        if  amount <= self.__balance:
            self.__balance -= amount
            print(f"Withdrew {amount}. New balance: {self.__balance}")
        else:
            print("Insufficient funds")

    def get_balance(self):
        return self.__balance 

In this example:

• __balance is a private attribute, accessible only within the class.
• deposit, withdraw, and get_balance are public methods to interact with the account.

Benefits of Encapsulation:

• Data protection: Prevents accidental modification of data.
• Increased security: Protects sensitive information.
• Code modularity: Enhances code organization and reusability.
• Improved maintainability: Easier to modify code without affecting other parts of the system.

By encapsulating data and methods within a class, you create a well-defined and protected unit, making your code more robust and reliable.

Read More..