Abstraction concept

In OOP, Abstraction enables you to represent essential aspects of an object without exposing its internal workings. It allows for designing classes that can interact with other parts of the system while hiding unnecessary complexities.

For example, in a banking application, you might need to interact with bank accounts, but you don’t need to know the complex algorithms that calculate interest or handle transactions. Instead, you only care about the essential methods and attributes like deposit(), withdraw(), and balance.

Bank Account Example

Let’s abstract the core functionality of a bank account by defining a BankAccount class that hides the internal logic while exposing essential methods for interacting with it.

classDiagram
class BankAccount {
  - Int accountNumber
  - Int balance 
  - String accountHolder
  + deposit(amount)
  + withdraw(amount)
  + getBalance()
} 

These represent the internal data of the BankAccount. By keeping these attributes private, we ensure that they cannot be accessed or modified directly by external code. For example, without abstraction, an external user could directly modify attributes like balance to any value, even negative amounts.

Abstraction protects this data, ensuring that changes are made through controlled methods like deposit(amount) and withdraw(amount).

These methods provide an interface to interact with the BankAccount object. Through abstraction, users can perform essential operations without needing to know how these methods are implemented internally.

Why Abstraction Matters?

Separation of Concerns

Abstraction ensures that each part of the system focuses on a specific task. The BankAccount class manages the account data internally, while external code only interacts with it through public methods. This separation makes the system easier to understand, maintain, and extend.

Security

By hiding the internal state of the object, we prevent unauthorized or unintended changes. For instance, without abstraction, a user could directly change the accountNumber of an account. Abstraction ensures that such sensitive data is protected, allowing only authorized interactions through the defined methods.

Simplified Interface

Users of the class only need to focus on what’s essential for them. A person using the BankAccount class doesn’t care about how the balance is stored in memory or how funds are transferred; they only care about interacting with the interface provided—depositing, withdrawing, and checking the balance.

Through Abstraction, we define a simple interface for interacting with objects, hiding unnecessary details while maintaining control over how data is accessed and modified. This principle enhances security, improves code maintainability, and ensures a cleaner, more understandable interface.