What are the four pillars of OOP?

1. Encapsulation

Encapsulation means keeping data and the methods that use it inside one class, and controlling access from the outside. You make fields private and expose safe methods to read or change them. Think of a capsule that protects what is inside.

class BankAccount {
    double balance = 0;                // hidden
public:
    void deposit(double amt) {         // controlled access
        if (amt > 0) balance += amt;
    }
};

class BankAccount {
    private double balance;            // hidden
    public void deposit(double amt) {  // controlled access
        if (amt > 0) balance += amt;
    }
}

class BankAccount:
    def __init__(self):
        self.__balance = 0             # hidden
    def deposit(self, amt):            # controlled access
        if amt > 0:
            self.__balance += amt

2. Abstraction

Abstraction means showing only what a user needs and hiding the messy details. When you drive a car you use the steering wheel and pedals. You do not need to know how the engine burns fuel. In code you expose a simple method and hide the complex logic behind it.

3. Inheritance

Inheritance lets a new class reuse the fields and methods of an existing class. The existing class is the parent and the new one is the child. A Dog class can inherit from an Animal class and automatically get its eat and sleep methods.

class Animal {
public:
    void eat() { cout << "eating"; }
};
class Dog : public Animal {   // Dog reuses eat()
public:
    void bark() { cout << "woof"; }
};

class Animal {
    void eat() { System.out.println("eating"); }
}
class Dog extends Animal {   // Dog reuses eat()
    void bark() { System.out.println("woof"); }
}

class Animal:
    def eat(self):
        print("eating")
class Dog(Animal):            # Dog reuses eat()
    def bark(self):
        print("woof")

4. Polymorphism

Polymorphism means one name behaving in many forms. The same method call can do different things depending on the object. A draw method on a Shape can draw a circle or a square based on which shape it actually is.