What is the difference between abstraction and encapsulation?

The easiest way to remember it

Abstraction hides complexity. Encapsulation hides data. They often work together but they solve different problems. Abstraction is a design decision about what to show, and encapsulation is a coding technique for how to protect the internal state.

Abstraction with a real example

When you send a message on your phone you tap send. You do not think about signals, towers, or network protocols. The app gives you a simple button and hides the hard parts. That is abstraction. In code you achieve it with abstract classes and interfaces.

class Payment {                    // abstract base as interface
public:
    virtual void pay(double amount) = 0;  // what it does, not how
    virtual ~Payment() = default;
};
class CardPayment : public Payment {
public:
    void pay(double amount) override {
        // complex card logic hidden here
    }
};

interface Payment {
    void pay(double amount);   // what it does, not how
}
class CardPayment implements Payment {
    public void pay(double amount) {
        // complex card logic hidden here
    }
}

from abc import ABC, abstractmethod

class Payment(ABC):
    @abstractmethod
    def pay(self, amount):   # what it does, not how
        ...
class CardPayment(Payment):
    def pay(self, amount):
        # complex card logic hidden here
        ...

Encapsulation with a real example

A medicine capsule wraps the ingredients so you cannot touch them directly. In code you make fields private and only allow changes through methods, so no one can put the object into a bad state.

class Student {
    int age = 0;                     // hidden data
public:
    void setAge(int a) {
        if (a > 0) age = a;          // controlled change
    }
};

class Student {
    private int age;                 // hidden data
    public void setAge(int a) {
        if (a > 0) age = a;          // controlled change
    }
}

class Student:
    def __init__(self):
        self.__age = 0               # hidden data
    def set_age(self, a):
        if a > 0:
            self.__age = a           # controlled change

Quick comparison

• Purpose: abstraction hides complexity, encapsulation hides data.
• Level: abstraction is at the design level, encapsulation is at the implementation level.
• Tools: abstraction uses interfaces and abstract classes, encapsulation uses access modifiers like private.
• Focus: abstraction focuses on what, encapsulation focuses on how.