Kokie yra keturi OOP ramsčiai?

Question

Accepted Answer

Objektinio programavimo kalbos pagrindas yra keturi pagrindiniai principai — **Hermetizacija, Paveldėjimas, Polimorfizmas ir Abstrakcija**. Java yra pagrįsta šiais principais, o jų supratimas yra esmingas kuriant Java programas.

## 1. Hermetizacija — duomenų grupavimas + vidinės dalies slėpimas

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

Hermetizacija slepia vidinę būseną (`private`) ir suteikia kontroliuojamą prieigą (viešus metodus/getter/setter). Tai saugo invariantu — negalite tiesiogiai nustatyti neigiamo balanso — ir leidžia keisti vidinę dalį nežeidžiant skambintojų.

## 2. Paveldėjimas — kodo pakartojimas per "is-a" santykį

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

Paveldėjimas leidžia poklasė pakartoti ir išplėsti viršklasės elgesį, modeliuojant "is-a" santykius ir išvengiant kodo dubliavimo.

## 3. Polimorfizmas — vienas interfeisas, daug 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
```

Polimorfizmas leidžia vienodai traktuoti skirtingus poklasės bendro tipo pagrindu, kai **tikras** objekto perrašytasis metodas yra iškviečiamas vykdymo metu — suteikiant lanksčią, išplečiamą kodą.

## 4. Abstrakcija — atskleisti ką, paslėpti kaip

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

Abstrakcija (per interfeisus/abstrakčias klases) atskleidi supaprastintą sutartį, o paslėpia sudėtingą įgyvendinimą — leidžia keisti įgyvendinimus ir sumažinti sąryšį.

## Kodėl tai svarbu

Keturi ramsčiai yra objektinio programavimo ir pačios Java pagrindas.

Hermetizacija apsaugo duomenų integritetą ir leidžia saugiems pakeitimams; paveldėjimas skatina kodo pakartojimą; polimorfizmas suteikia lankstumo ir išplečiamumo (traktuoti daug tipų vienodai, elgesys išsprendžiamas vykdymo metu); abstrakcija sumažina sąryšį ir sudėtingumą.

Jų supratimas nėra tik terminologija — jie nukreipia, kaip jūs struktūrizuojate klases, projektuojate API ir kuriate palaikomus, išplečiamus sistemas.

Jie taip pat yra tarp dažniausių interviu temų, nes rodo, ar kūrėjas galvoja tinkamais OOP terminais, o tai svarbu veikti efektyviai Java klasei skirtuose ekosistemoje.