Menene bambanci tsakanin interface da abstract class?

Question

Accepted Answer

Duka biyu suna bayyana nau'ikan abstrakta waɗanda ba za a iya aiki da su kai tsaye ba kuma an shirya su ne don aiwatarwa/fadada — amma suna bugi manufofin zane-zane daban. Bambancin mahimmanci sune **gida inheritance da yawa**, **state**, da dangantakar da suke bayyana.

## Interface — alkawari ("zai iya yi" / iyawa)

```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 yana bayyana **alkawari** na hali. Ajin zai iya aiwatar **da yawa** interfaces — wannan shi ne yadda Java ke samun nau'in gida inheritance da yawa. Interfaces (na dace) ba su da yajin state na ajin.

## Abstract class — wanda ba daram ("ne" tare da shared code)

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

Abstract class zai iya dauke da **state (fields)**, **constructors**, da hanyoyin concrete tare da aiwatarwar shared — amma ajin zai iya fadada **ɗaya kawai** abstract class (gida inheritance gida).

## Bambancin mahimmanci

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

## Lokacin amfani da wanne

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

## Me ya sa yana da mahimmanci

Zabar tsakanin interface da abstract class shine yanke-yanken zane-zane na mahimmanci na Java.

Interfaces suna bayyana **alkawari/iyawa** kuma suna baiwa ajin damar aiwatar da yawa daga cikinsu (amsweri na Java ga gida inheritance da yawa) — ya fi dacewa don iyawar da za a iya yi daga juna.

Abstract classes suna bada **shared base tare da state da aiwatarwar waje** ga ajin da ke da dangantaka kafo, amma suna damje ka ga gida inheritance gida.

Jisanta da bambance-bambance (aiwatarwa da yawa da adadi vs shared-state/constructors, iyawa vs ne dangantaka) tana gabatarwa da kyakkyawar zane-zane na API da ajin-hierarchy.

Tare da Java 8+ default methods waɗanda ke warware layin, sanin lokacin kowannen yana dace — da mahimmancin ƙyale (abstract class ɗaya amma interfaces da yawa, state kawai a cikin abstract classes) — ya zama wajib don zane-zanen flexible, code mai kyau.