რა არის OOP-ის ოთხი სვეტი?

Question

Accepted Answer

ობიექტზე ორიენტირებული პროგრამირება ეფუძნება ოთხ ძირითად პრინციპს — **ინკაპსულაცია, მემკვიდრეობა, პოლიმორფიზმი და აბსტრაქცია**. Java აგებულია ამ საფუძველზე, და მათი გაგება აუცილებელია Java პროგრამების დიზაინისთვის.

## 1. ინკაპსულაცია — მონაცემების შეკუმშვა + შიგნითი ნაწილების დამალვა

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

ინკაპსულაცია ფარავს შიგნით მდგომარეობას (`private`) და ასაჯაროებს კონტროლირებულ წვდომას (საჯაროო მეთოდები/getter/setter). ეს ინვარიანტებს იცავს — თქვენ არ შეგიძლიათ უარყოფითი ბალანსი პირდაპირ დააყენოთ — და საშუალებას გაძლევთ შიგნით ნაწილი შეცვალოთ დამწოდებელი გარეშე.

## 2. მემკვიდრეობა — კოდის ხელახალი გამოყენება "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"); }
}
```

მემკვიდრეობა საშუალებას აძლევს ქვეკლასს თავიდან გამოიყენოს და გაფართოოს სამეფო კლასის ქცევა, მოდელირებაა "is-a" ურთიერთობებისა და კოდის დუბლირებისგან თავის აშორება.

## 3. პოლიმორფიზმი — ერთი ინტერფეისი, მრავალი ფორმა

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

პოლიმორფიზმი საშუალებას გაძლევთ სხვადსხვა ქვეკლასებს ჯამურად განიხილოთ საერთო ტიპის მეშვეობით, **რეალური** ობიექტის გადანიშნული მეთოდი რომელიც იძახება runtime-ზე — დინამიური, გაფართოვადი კოდის ხელმისაწვდომობა.

## 4. აბსტრაქცია — გამოავლინე რა, დაფარე როგორ

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

აბსტრაქცია (ინტერფეისების/აბსტრაქტული კლასების მეშვეობით) ასაჯაროებს გამარტივებულ ხელშეკრულებას დახვეწილი განხორციელების დამალვის დროს — საშუალებას გაძლევთ განხორციელებების შეცვლა და დეკოპლინგის შემცირება.

## რატომ არის ეს მნიშვნელოვანი

ოთხი სვეტი ობიექტზე ორიენტირებული დიზაინისა და თავად Java-ს საფუძველია.

ინკაპსულაცია იცავს მონაცემთა სისტემურობას და ხელმისაწვდომლობას უსაფრთხო ცვლილებების; მემკვიდრეობა წაქმნის კოდის ხელახლა გამოყენებას; პოლიმორფიზმი უმცროვანი მოქნილობა და გაფართოვადობა (მრავალი ტიპის გამელნივე განხილვა, ქცევა runtime-ზე გადაჭრილი); აბსტრაქცია კლებს დეკოპლინგს და სირთულეს.

მათი გაგება არ არის მხოლოდ ტერმინოლოგია — ეს კითხვებში მოძღვნის თუ როგორ სტრუქტურირებული თქვენი კლასებს, რა არის API დიზაინი და როგორ აგებულია აღმავალი, გაფართოვადი სისტემა.

ისინი ასევე ერთ-ერთი ყველაზე ხშირი ინტერვიუს თემაა, რადგან ისინი ნაჩვენებია თუ ხომ დეველოპერი ფიქრობს სწორი OOP ტერმინოლოგიით, რაც აუცილებელია Java-ს კლასზე დაფუძნებულ ეკოსისტემაში ეფექტიანად მუშაობის თვალსაზრისით.