Jakie są cztery filary programowania obiektowego?

Question

Accepted Answer

Programowanie obiektowe opiera się na czterech podstawowych zasadach — **Enkapsulacja, Dziedziczenie, Polimorfizm i Abstrakcja**. Java jest zbudowana wokół nich, a ich zrozumienie jest fundamentalne dla projektowania programów w Javie.

## 1. Enkapsulacja — 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; }
}
```

Enkapsulacja ukrywa stan wewnętrzny (`private`) i udostępnia kontrolowany dostęp (metody publiczne/gettery/settery). Chroni to invarianty — nie możesz bezpośrednio ustawić ujemnego salda — i pozwala na zmianę wewnętrzności bez łamania dla wywołujących.

## 2. Dziedziczenie — ponowne użycie poprzez relację "is-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"); }
}
```

Dziedziczenie pozwala klasie pochodnej na ponowne użycie i rozszerzenie zachowania klasy bazowej, modelując relacje "is-a" i unikając powielania kodu.

## 3. Polimorfizm — jeden interfejs, wiele form

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

Polimorfizm pozwala na traktowanie różnych klas pochodnych jednolicie poprzez wspólny typ, przy czym **faktyczna** metoda nadpisana obiektu jest wywoływana w czasie wykonania — umożliwiając elastyczny i rozszerzalny kod.

## 4. Abstrakcja — ujawnij co, ukryj 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();
```

Abstrakcja (poprzez interfejsy/klasy abstrakcyjne) ujawnia uproszczony kontrakt, ukrywając złożoną implementację — pozwalając na wymianę implementacji i zmniejszenie sprzężenia.

## Dlaczego to ważne

Cztery filary są fundamentem projektowania obiektowego i samej Javy.

Enkapsulacja chroni integralność danych i umożliwia bezpieczną zmianę; dziedziczenie promuje ponowne użycie; polimorfizm zapewnia elastyczność i rozszerzalność (traktuj wiele typów jednolicie, zachowanie rozwiązane w czasie wykonania); abstrakcja zmniejsza sprzężenie i złożoność.

Zrozumienie ich to nie tylko terminologia — kierują one tym, jak strukturyzujesz klasy, projektujesz API i budujesz łatwe w utrzymaniu i rozszerzalne systemy.

Są to również jedne z najczęstszych tematów rozmów kwalifikacyjnych, ponieważ ujawniają, czy programista myśli w odpowiednich kategoriach OOP, co jest niezbędne do efektywnej pracy w ekosystemie Javy skoncentrowanym na klasach.