Mi az OOP négy pillére?

Question

Accepted Answer

Az objektum-orientált programozás négy alapvető elvren — **Encapsulation, Inheritance, Polymorphism és Abstraction** — alapul. A Java ezek körül épül fel, és megértésük alapvetőek a Java programok tervezéséhez.

## 1. Encapsulation — adatok csomagolása + a belső meghallgatás

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

Az Encapsulation elrejti a belső állapotot (`private`) és szabályozott hozzáférést (nyilvános metódusok/gettersek/settersek) nyújt. Ez megvédi az invariánsokat — nem állíthatsz be közvetlenül negatív egyenleget — és lehetővé teszi az internálisok megváltoztatását a hívó megtörése nélkül.

## 2. Inheritance — újrafelhasználás egy "is-a" kapcsolaton keresztül

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

Az Inheritance lehetővé teszi egy alosztálynak, hogy újrafelhasználja és kiterjesszen egy felületi osztály viselkedését, "is-a" kapcsolatokat modellezzen és elkerülje a kód duplikálást.

## 3. Polymorphism — egy interfész, sok forma

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

A Polymorphism lehetővé teszi, hogy különböző alosztályokat egységesen kezeld egy közös típuson keresztül, ahol az **aktuális** objektum felülírt metódusa futási időben hívódik meg — lehetővé tesz rugalmas, kiterjeszthető kódot.

## 4. Abstraction — feltárni mit, elrejteni hogyan

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

Az Abstraction (interfészeken/absztrakt osztályokon keresztül) egy leegyszerűsített szerződést tesz nyilvánossá, miközben elrejti az összetett implementációt — lehetővé teszi az implementációk felcserélését és a csatolás csökkentését.

## Miért fontos

A négy pillér az objektum-orientált tervezés és maga a Java alapja.

Az Encapsulation megvédi az adatok integritását és biztonságos változást tesz lehetővé; az Inheritance előmozdítja az újrafelhasználást; a Polymorphism rugalmasságot és kiterjeszthetőséget biztosít (sok típust egységesen kezeljünk, a viselkedés futási időben dől el); az Abstraction csökkenti a csatolást és az összetettséget.

Megértésük nem csupán terminológia — arra irányít, hogyan strukturáld az osztályokat, tervezz API-kat és építs karbantartható, kiterjeszthető rendszereket.

Ezek a leggyakoribb interjúkérdések közé tartoznak, mert azt mutatják, hogy a fejlesztő megfelelő OOP-kifejezésekben gondolkodik-e, ami lényeges a Java class-centric ökoszisztémájában való hatékony munkavégzéshez.