Abstraction and encapsulation are both fundamental concepts of object-oriented programming (OOP), but they serve different purposes and operate at different levels. Here’s a simple explanation:

1. Abstraction

  • What it is: Abstraction focuses on hiding unnecessary details and showing only the essential features of an object. It defines “what an object does” rather than “how it does it.”
  • Purpose: To simplify complex systems by breaking them into smaller, more manageable parts and exposing only relevant details to the user.
  • Example: Think of a TV remote:
    • You know the buttons to turn the TV on, change channels, and adjust the volume.
    • You don’t know or care how the remote internally sends signals to the TV—that’s abstracted away.

In code:

// Abstract class representing a Vehicle
abstract class Vehicle {
    abstract void startEngine(); // No implementation here
}

class Car extends Vehicle {
    @Override
    void startEngine() {
        System.out.println("Car engine started.");
    }
}
  • The Vehicle class provides an abstract definition (only “what to do”), and the Car class implements the details (the “how”).

2. Encapsulation

  • What it is: Encapsulation focuses on hiding the internal state of an object and restricting direct access to it. This is achieved by bundling the data (fields) and methods (functions) that manipulate the data into a single unit (class) and controlling access via access modifiers like private, public, and protected.
  • Purpose: To ensure data security and prevent unauthorized access or modifications.
  • Example: Think of a capsule pill:
    • The medicine inside is hidden and protected from the outside.
    • You can only access it by taking the pill as a whole.

In code:

class BankAccount {
    private double balance; // Private field

    // Public method to access and modify the balance
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    public double getBalance() {
        return balance;
    }
}
  • The balance field is hidden (private), and access is controlled via the deposit and getBalance methods.

Key Differences

Aspect Abstraction Encapsulation
Focus Hiding implementation details. Hiding internal data.
What is hidden? Complexity (how something works). Internal state of an object.
How is it achieved? Using abstract classes, interfaces. Using access modifiers (private, etc.).
Purpose Simplify usage by exposing only essentials. Protect data and ensure controlled access.
Example Abstract class or interface (defines a “what”). Class with private fields and public methods.

Potential Interview Questions

  1. Can you implement a simple example of abstraction in Java?
  2. How does encapsulation improve the security of a program?
  3. Can abstraction and encapsulation be used together? If yes, how?
  4. What is the difference between an abstract class and an interface in Java (related to abstraction)?

Check out the video for a detailed explanation: