Care sunt cele patru piloni ai programării orientate pe obiecte?

Question

Accepted Answer

Programarea orientată pe obiecte se bazează pe patru principii fundamentale — **Incapsulare, Moștenire, Polimorfism și Abstracție**. Java este construită în jurul acestora, iar înțelegerea lor este fundamentală pentru proiectarea programelor Java.

## 1. Incapsulare — grupează date + ascunde detaliile interne

```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; }
}
```

Incapsularea ascunde starea internă (`private`) și expune acces controlat (metode publice/getteri/setteri). Aceasta protejează invarianții — nu puteți seta direct un sold negativ — și vă permite să schimbați detaliile interne fără a afecta apelatorii.

## 2. Moștenire — refolosire prin relația "este-un"

```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"); }
}
```

Moștenirea permite unei subclase să reutilizeze și să extindă comportamentul unei superclase, modelând relații "este-un" și evitând duplicarea codului.

## 3. Polimorfism — o interfață, mai multe forme

```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
```

Polimorfismul vă permite să tratați diferite subclase uniform printr-un tip comun, cu metoda suprascrisă a obiectului **actual** fiind apelată la runtime — permițând cod flexibil și extensibil.

## 4. Abstracție — expune ce, ascunde cum

```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();
```

Abstracția (prin interfețe/clase abstracte) expune un contract simplificat în timp ce ascunde implementarea complexă — permițând înlocuirea implementărilor și reducerea cuplajului.

## De ce conteaza

Cei patru piloni sunt fundamentul design-ului orientat pe obiecte și ai Java-ului însuși.

Incapsularea protejează integritatea datelor și permite schimbări sigure; moștenirea promovează refolosirea; polimorfismul oferă flexibilitate și extensibilitate (tratați mai multe tipuri uniform, comportamentul rezolvat la runtime); abstracția reduce cuplajul și complexitatea.

Înțelegerea lor nu este doar o chestiune de terminologie — ele ghidează cum structurați clasele, proiectați API-urile și construiți sisteme menținute și extensibile.

Sunt, de asemenea, printre cele mai frecvente subiecte de interviu deoarece relevă dacă un dezvoltator gândește în termeni corespunzători OOP, ceea ce este esențial pentru a lucra eficient în ecosistemul centrat pe clase al Java-ului.