Jaké jsou čtyři pilíře OOP?

Question

Accepted Answer

Objektově orientované programování spočívá na čtyřech základních principech — **Zapouzdření, Dědičnost, Polymorfismus a Abstrakce**. Java je postavena na těchto principech a jejich pochopení je zásadní pro navrhování Java programů.

## 1. Zapouzdření — sjednocení dat + skrytí 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; }
}
```

Zapouzdření skrývá vnitřní stav (`private`) a poskytuje kontrolovaný přístup (veřejné metody/gettery/settery). To chrání invarianty — nemůžete přímo nastavit záporný zůstatek — a umožňuje vám měnit internals bez rozbití volajících.

## 2. Dědičnost — znovupoužití přes vztah "je-a"

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

Dědičnost umožňuje podtřídě znovupoužít a rozšířit chování nadtřídy, modeluje vztahy "je-a" a vyhýbá se duplikaci kódu.

## 3. Polymorfismus — jedno rozhraní, mnoho forem

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

Polymorfismus vám umožňuje jednotně zacházet s různými podtřídami prostřednictvím společného typu, přičemž **skutečný** objekt má za běhu volánu svou přepsanou metodu — umožňuje flexibilní a rozšiřitelný kód.

## 4. Abstrakce — odhalit co, skrýt jak

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

Abstrakce (přes rozhraní/abstraktní třídy) odhaluje zjednodušenou smlouvu a zároveň skrývá komplexní implementaci — umožňuje vám vyměňovat implementace a snižovat vazbu.

## Proč je to důležité

Čtyři pilíře jsou základem objektově orientovaného návrhu a samotné Java.

Zapouzdření chrání integritu dat a umožňuje bezpečné změny; dědičnost podporuje znovupoužití; polymorfismus poskytuje flexibilitu a rozšiřitelnost (jednotné zacházení s mnoha typy, chování řešeno za běhu); abstrakce snižuje vazbu a složitost.

Jejich pochopení není jen terminologie — vedou k tomu, jak strukturujete třídy, navrhujete API a budujete udržovatelné, rozšiřitelné systémy.

Sou také mezi nejčastějšími tématy v interview, protože odhalují, zda vývojář myslí v správných OOP termínech, což je nezbytné pro efektivní práci v ekosystému Java se třídami v centru.