Menene abubuwan gida hudu na OOP?

Question

Accepted Answer

Shirye-shiryen da aka gane a kan abubuwan hudu mahimmance — **Encapsulation, Inheritance, Polymorphism, da Abstraction**. Java aka gina shi kasar waɗannan, kuma fahimtar su mahimmanci ne don ƙera shirye-shiryen Java.

## 1. Encapsulation — tutara bayani + ɓoye cikin jiya

```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 yana ɓoye jihar ciki (`private`) kuma yana bayar da shawo aman (juna hanyoyi/getters/setters). Wannan yana gare da amintaccen gaida — ba za ka iya saita daidai jiya mai cikin jiya — kuma yana ba ka damar canja bayani cikin jiya ba tare da karya kiran.

## 2. Inheritance — sake amfani ta hanyar "is-a" dangantaka

```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 yana ba da damar subclass don sake amfani da kuma tsawaita halayen superclass, yana zama "is-a" dangantaka kuma yana guje da jita jita.

## 3. Polymorphism — gida daya, yawancin nau'i

```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 yana ba da damar ka nuna subclass iri-iri a gida daya ta nau'in gida, tare da **ainihi** jerin shine shine ake kira a lokacin gudu — yana ba da gida mai dikitaccen tsari kuma yana fadada.

## 4. Abstraction — bayar da jadwal, ɓoye yadda

```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 (ta hanyar interfaces/abstract classes) yana bayar da saukar saukar a hannu kuma yana ɓoye hadaddiyar aiwatarwa — yana ba da damar ka canza aiwatarwa kuma ka rage dangantaka.

## Me ya sa akwai mahimmanci

Abubuwan gida hudu sune tushe na ƙera shirye-shiryen OOP kuma na Java kanta.

Encapsulation yana gare da amintaccen bayani kuma yana ba da damar canja saukar; Inheritance yana haɓaka sake amfani; Polymorphism yana ba da jinkiri da haɓakawa (nuni da yawancin nau'i a gida daya, hali aka ƙayyade a lokacin gudu); Abstraction yana rage dangantaka da hadaddiyar.

Fahimtar su ba baje ce — suna jagorar yadda ka tsara jerin, ka ƙera APIs, kuma ka gina jerin masu tushe kuma jerin da za a iya fadawa.

Su ma sune jerin buɗan jerin jerin don yadda suka bayar hanya don jadwal ƙarfi OOP, wanda ya zama mahimmanci don aiwata sannu a cikin Java na jerin cikin cikaken kadai.