Koja su četiri stupa OOP-a?

Question

Accepted Answer

Objektno orijentirano programiranje počiva na četiri temeljna principa — **Encapsulation, Inheritance, Polymorphism i Abstraction**. Java je izgrađena oko ovih principa, a njihovo razumijevanje je temeljno za dizajniranje Java programa.

## 1. Encapsulation — grupiraj podatke + sakrij interna

```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 skriva interno stanje (`private`) i izlaže kontrolirani pristup (javne metode/getters/setters). Ovo štiti invarijante — ne možeš izravno postaviti negativan saldo — i omogućava ti promjenu internih dijelova bez sloma pozivateljima.

## 2. Inheritance — ponovno korištenje kroz "is-a" odnos

```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 omogućava podklasi da ponovno koristi i proširi ponašanje nadklase, modelira "is-a" odnose i izbjegava dupliciranje koda.

## 3. Polymorphism — jedno sučelje, mnogo oblika

```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 ti omogućava da različite podklase tretiraš jednoliko kroz zajedničku vrstu, s tom da se **stvarni** objekt overridden metoda poziva tijekom izvršavanja — omogućuje fleksibilan, proširljiv kod.

## 4. Abstraction — izloži što, sakrij kako

```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 (putem sučelja/apstraktnih klasa) izlaže pojednostavljeni ugovor dok skriva složenu implementaciju — omogućava ti zamjenu implementacija i smanjuje vezanost.

## Zašto je to važno

Četiri stupa su temelj objektno orijentiranog dizajna i samoga Java-a.

Encapsulation štiti integritet podataka i omogućava sigurnu promjenu; Inheritance promovira ponovno korištenje; Polymorphism daje fleksibilnost i proširljivost (tretirati mnogo vrsta jednoliko, ponašanje razriješeno tijekom izvršavanja); Abstraction smanjuje vezanost i složenost.

Razumijevanje ih nije samo terminologija — vode kako strukturiraš klase, dizajniraš API-je i gradiš održive, proširljive sustave.

Oni su također među najčešćim temama intervjua jer pokazuju je li razvijač razmišljao u pravilnim OOP pojmovima, što je bitno za učinkovito rad u Java-ovom class-centričnom ekosustavu.