Ni nini nguzo nne za OOP?

Question

Accepted Answer

Programu inayolenga vitu (object-oriented programming) inategemea kanuni nne za msingi — **Encapsulation, Inheritance, Polymorphism, na Abstraction**. Java imejengwa kuzunguka hizi, na kuzielewa ni jambo la msingi katika kubuni programu za Java.

## 1. Encapsulation — kuunganisha data + kuficha sehemu za ndani

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

Encapsulation huficha hali ya ndani (`private`) na hufichua ufikiaji unaodhibitiwa (mbinu/getters/setters za umma). Hii hulinda invariants — huwezi kuweka balance hasi moja kwa moja — na hukuwezesha kubadilisha sehemu za ndani bila kuvunja wanaoitisha.

## 2. Inheritance — kutumia tena kupitia uhusiano wa "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"); }
}
```

Inheritance huruhusu subclass kutumia tena na kupanua tabia ya superclass, ikionyesha uhusiano wa "is-a" na kuepuka kurudia msimbo.

## 3. Polymorphism — kiolesura kimoja, maumbo mengi

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

Polymorphism hukuwezesha kushughulikia subclasses tofauti kwa njia sare kupitia aina ya pamoja, ambapo mbinu iliyobadilishwa (overridden) ya kitu **halisi** huitwa wakati wa utekelezaji (runtime) — ikiwezesha msimbo unaonyumbulika na unaopanuka.

## 4. Abstraction — kufichua nini, kuficha jinsi gani

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

Abstraction (kupitia interfaces/abstract classes) hufichua mkataba uliorahisishwa huku ikificha utekelezaji tata — ikikuwezesha kubadilisha utekelezaji na kupunguza coupling.

## Kwa nini ni muhimu

Nguzo nne ni msingi wa muundo unaolenga vitu na wa Java yenyewe.

Encapsulation hulinda uadilifu wa data na huwezesha mabadiliko salama; inheritance huhimiza kutumia tena; polymorphism hutoa unyumbufu na uwezo wa kupanuka (kushughulikia aina nyingi kwa njia sare, tabia ikatatuliwa wakati wa runtime); abstraction hupunguza coupling na utata.

Kuzielewa si istilahi tu — zinaongoza jinsi unavyopanga classes, kubuni APIs, na kujenga mifumo inayotunzika na kupanuka.

Pia ni miongoni mwa mada za mahojiano zinazojulikana zaidi kwa sababu zinaonyesha kama developer anafikiri kwa misingi sahihi ya OOP, jambo ambalo ni muhimu kwa kufanya kazi kwa ufanisi katika mfumo wa Java unaozingatia classes.