Ni nini tofauti kati ya interface na darasa la abstract?

Question

Accepted Answer

Zote mbili zinafafanua aina za abstract ambazo haziwezi kukamatia moja kwa moja na zimekusudiwa kutekelezwa/kupanuliwa — lakini hutumia madhumuni tofauti ya muundo. Tofauti muhimu ni **urithi mwingi**, **hali** na mahusiano ambayo yanamfanya.

## Interface — mkataba ("inaweza-kufanya" / uwezo)

```java
public interface Drawable {
    void draw();                          // abstract method (implicitly public abstract)

default void render() {                // default method — has a body (Java 8+)
        System.out.println("rendering");
    }
    int MAX = 100;                         // implicitly public static final (constant only)
}

class Circle implements Drawable {
    public void draw() { /* must implement */ }
}
```

Interface inafafanua **mkataba** wa tabia. Darasa linaweza kutekeleza **interface nyingi** — hii ndiyo jinsi Java inavyopatia aina ya urithi mwingi. Interface (kawaida) haina hali ya kitu.

## Darasa la abstract — msingi wa sehemu ("ni-a" na msimbo unaoshirikiwa)

```java
public abstract class Animal {
    protected String name;                 // ✅ can have instance FIELDS (state)

public Animal(String name) {           // ✅ can have a constructor
        this.name = name;
    }
    public abstract void makeSound();      // abstract — subclasses must implement
    public void sleep() {                   // ✅ concrete method with shared logic
        System.out.println(name + " sleeps");
    }
}

class Dog extends Animal {                 // can extend only ONE class
    public Dog(String n) { super(n); }
    public void makeSound() { System.out.println("Woof"); }
}
```

Darasa la abstract linaweza kuandika **hali (sehemu)**, **wajenzi** na njia halisi na utekelezaji unaoshirikiwa — lakini darasa linaweza kupanua tu darasa **moja** la abstract (urithi mmoja).

## Tofauti muhimu

```text
                    Interface              Abstract class
Multiple inheritance ✓ (implement many)    ✗ (extend only one)
Instance fields/state ✗ (constants only)   ✓ (fields)
Constructor           ✗                    ✓
Method bodies         default/static only  ✓ (concrete methods)
Models                capability ("can-do") "is-a" with shared base
```

## Ni lini kutumia ipi

```text
Interface → define a capability multiple unrelated classes can have
            (Comparable, Runnable, Serializable); when you need multiple inheritance
Abstract class → share common state + code among closely related subclasses
            (a base class with fields and partial implementation)
```

## Kwa nini linalohitaji

Kuchagua kati ya interface na darasa la abstract ni uamuzi wa kimsingi wa muundo wa Java.

Interface zinafafanua **mkataba/uwezo** na zinakamatisha darasa kutekeleza nyingi kati yao (jibu la Java kwa urithi mwingi) — bora kwa uwezo unaoupitisha mipaka.

Darasa la abstract hutoa **msingi unaoshirikiwa na hali na utekelezaji wa sehemu** kwa madarasa madogo yanayohusiana, lakini yakukidi kwa urithi mmoja.

Kuelewa mabadilisho (utekelezaji mwingi dhidi ya hali/wajenzi unaoshirikiwa, uwezo dhidi ya mahusiano ya ni-a) inaongoza muundo mzuri wa API na huduma ya tabaka.

Kwa njia za kawaida za Java 8+ zinazofuta mstari, kujua wakati kila moja inafaa — na kuzuia kwenye msingi (darasa moja la abstract lakini interface nyingi, hali katika darasa la abstract tu) — ni muhimu kwa kujenga msimbo unaobadilika, wenye muundo mzuri.