What are the four pillars of OOP?

Question

Accepted Answer

Object-oriented programming rests on four core principles — **Encapsulation, Inheritance, Polymorphism, and Abstraction**. Java is built around these, and understanding them is fundamental to designing Java programs.

## 1. Encapsulation — bundle data + hide internals

```java
public class Account {
    private double balance;          // hidden — can't be accessed directly outside

public void deposit(double amount) {   // controlled access via methods
        if (amount > 0) balance += amount;  // can enforce rules
    }
    public double getBalance() { return balance; }
}
```

Encapsulation hides internal state (`private`) and exposes controlled access (public methods/getters/setters). This protects invariants — you can't set a negative balance directly — and lets you change internals without breaking callers.

## 2. Inheritance — reuse via an "is-a" relationship

```java
class Animal {
    void eat() { System.out.println("eating"); }
}
class Dog extends Animal {   // Dog IS-A Animal — inherits eat()
    void bark() { System.out.println("woof"); }
}
```

Inheritance lets a subclass reuse and extend a superclass's behavior, modeling "is-a" relationships and avoiding code duplication.

## 3. Polymorphism — one interface, many forms

```java
Animal a = new Dog();     // a Dog treated as an Animal
a.makeSound();            // calls Dog's overridden version at RUNTIME (dynamic dispatch)

// the same method behaves differently depending on the actual object:
List<Animal> animals = List.of(new Dog(), new Cat());
for (Animal animal : animals) animal.makeSound(); // each makes its own sound
```

Polymorphism lets you treat different subclasses uniformly through a common type, with the **actual** object's overridden method called at runtime — enabling flexible, extensible code.

## 4. Abstraction — expose what, hide how

```java
interface PaymentProcessor {
    void pay(double amount);   // WHAT it does, not HOW
}
class StripeProcessor implements PaymentProcessor {
    public void pay(double amount) { /* complex implementation hidden */ }
}
// callers depend on the abstraction, not the concrete implementation
PaymentProcessor processor = new StripeProcessor();
```

Abstraction (via interfaces/abstract classes) exposes a simplified contract while hiding complex implementation — letting you swap implementations and reduce coupling.

## Why it matters

The four pillars are the foundation of object-oriented design and of Java itself.

Encapsulation protects data integrity and enables safe change; inheritance promotes reuse; polymorphism provides flexibility and extensibility (treat many types uniformly, behavior resolved at runtime); abstraction reduces coupling and complexity.

Understanding them isn't just terminology — they guide how you structure classes, design APIs, and build maintainable, extensible systems.

They're also among the most common interview topics because they reveal whether a developer thinks in proper OOP terms, which is essential for working effectively in Java's class-centric ecosystem.