Encapsulation and abstraction are two important concepts in object-oriented programming.
Encapsulation refers to the practice of “encapsulating” data and methods within a single unit, called a class. This means that the class provides specific methods to access and modify the data while hiding the data itself from outside code. Encapsulation provides a way to protect the data from unintended changes, ensuring that the class behaves as expected.
Abstraction refers to the practice of hiding the complexity of a system by providing a simplified interface. This means that the user of a class only needs to know how to use the methods provided by the class, without having to worry about how the class actually works. Abstraction provides a way to manage complexity, making it easier to use and maintain software systems.
To achieve encapsulation in Python, one can use private variables and methods marked with a double underscore prefix. Accessing such variables and methods directly from outside the class is not possible, but public methods defined within the class can provide access to them.
Interfaces can achieve abstraction by defining a set of methods that any class implementing the interface must implement. This allows users of the interface to interact with any class that implements it, without having to know the specific implementation details of the class.
Here’s an example of encapsulation and abstraction in Python:
class BankAccount: def __init__(self, balance): self.__balance = balance def deposit(self, amount): self.__balance += amount def withdraw(self, amount): if amount > self.__balance: raise ValueError("Insufficient balance") self.__balance -= amount def get_balance(self): return self.__balance class Bank: def __init__(self): self.__accounts =  def add_account(self, account): self.__accounts.append(account) def total_balance(self): return sum(account.get_balance() for account in self.__accounts)
In this example,
BankAccount is a class that represents a bank account. The
balance of the account is stored in a private variable
__balance, and can only be accessed or modified through the public methods
Bank is another class that represents a bank, and contains a list of
BankAccount objects. The
add_account method is used to add an account to the list, and the
total_balance method is used to calculate the total balance of all accounts in the list.
By using encapsulation, the
BankAccount class ensures that the
balance data is protected and can only be accessed or modified through specific methods. By using abstraction, the
Bank class provides a simplified interface for interacting with bank accounts, without having to know the specific implementation details of the
class BankAccount: def __init__(self, account_number, balance): self.__account_number = account_number self.__balance = balance def deposit(self, amount): self.__balance += amount def withdraw(self, amount): if amount <= self.__balance: self.__balance -= amount else: print("Insufficient funds.") def get_balance(self): return self.__balance account = BankAccount("123456", 1000) account.deposit(500) print(account.get_balance()) # Output: 1500 account.withdraw(2000) # Output: Insufficient funds. print(account.get_balance()) # Output: 1500
In this example, we define a class
BankAccount that has two private attributes
__balance. We make these attributes private using double underscores, which encapsulates them and prevent direct access from outside the class..
The class also has three methods:
deposit the method allows deposits to be made to the account, the
withdraw method allows withdrawals to be made as long as there are sufficient funds, and the
get_balance method returns the current balance of the account.
These methods simplify the account by abstracting away details such as how the balance is calculated or where the account is stored. As a result, users can interact with the account using a simplified interface provided by these methods This showcases how abstraction can simplify the complexity of a system and offer a higher-level interface for users