Inheritance, abstract classes, da interfaces suna aiki fa?

Question

Accepted Answer

PHP tana goyan jajirewa na OOP da abstraction ta hanyoyi gida gida: **class inheritance** (`extends`), **abstract classes** (partial base classes), da **interfaces** (contracts). Kowanne yana yin aiki na nau'i na yadda ake tsara.

## Inheritance — yi tsari parent class

```php
<?php
class Animal {
    public function __construct(protected string $name) {}
    public function eat(): string { return "{$this->name} eats"; }
}

class Dog extends Animal {              // Dog inherits Animal's members
    public function bark(): string { return "Woof"; }
    public function eat(): string {     // override
        return parent::eat() . " noisily";   // parent:: calls the superclass method
    }
}
```

A subclass `extends` parent, yana karba abokan sa sannan lokaci-lokaci yana canza komai. `parent::` yana kira hanyar parent da aka canza. PHP tana goyan **single inheritance** (parent guda ne kawai).

## Abstract classes — partial base (ba za a iya yin abubuwa daga gida ba)

```php
abstract class Shape {
    abstract public function area(): float;     // abstract — subclasses MUST implement
    public function describe(): string {         // concrete — shared implementation
        return "Area: " . $this->area();
    }
}
class Circle extends Shape {
    public function __construct(private float $r) {}
    public function area(): float { return 3.14159 * $this->r ** 2; }   // must implement
}
// new Shape();  // ❌ error — abstract classes can't be instantiated
```

An **abstract class** yana daidaita abstract methods (subclasses dole ne su jera) da concrete shared code — base wanda ba za a iya yin abubuwan daga gida ba kai tsaye.

## Interfaces — pure contracts (maraka da yawa suna halal)

```php
interface Drawable {
    public function draw(): void;       // only signatures — no implementation
}
interface Serializable {
    public function serialize(): string;
}

class Widget implements Drawable, Serializable {   // implement MULTIPLE interfaces
    public function draw(): void { /* ... */ }
    public function serialize(): string { return "..."; }
}
```

An **interface** yana bayyana contract (method signatures, ba jera ba). A class na **da yawa** interfaces — hanyar PHP don raba iyawa.

## Lokacin da za a yi amfani da komai

```text
extends (inheritance) → "is-a" relationship, reuse + override behavior
abstract class → a base with SHARED code + methods subclasses must implement (single)
interface → a CONTRACT/capability multiple unrelated classes can fulfill (multiple)
→ "Program to an interface" — depend on interfaces for flexible, testable designs.
```

## Me yasa ya dogara

Inheritance, abstract classes, da interfaces sune kayan aiki na OOP gida gida, kuma fahimta bambance-bambancensu yana da mahimmanci don tsara PHP applications masu kyau (da kuma aiki da frameworks, waɗanda suke taba wadannan). **Inheritance** (`extends`) yana ba da sake amfani da code ta hanyar "is-a" relationships, amma PHP yana yarda da single inheritance kawai. **Abstract classes** yana ba da shared base tare da duka jera code da methods subclasses dole ne su bayyana — kyau ne don classes da suka dani tare suna raba logic. **Interfaces** yana bayyana contracts/capabilities, kuma muhimmanci ne class na iya **maraka" daga ciki — yin interfaces mabuɗi don designs masu kyau, waɗanda ba su daure, da jawabi PHP ga halin single-inheritance.

Sanin lokacin da za a yi amfani da komai (inheritance domin is-a reuse, abstract classes domin shared partial implementation, interfaces domin contracts/capabilities), da **programming to interfaces** (dogara ga abstractions domin code da za a iya gwaji, flexible, da yadda frameworks ake so), shi ne mahimmanci ilimi domin object-oriented PHP design.

Wadannan hanyoyi sune asali ga yadda frameworks kamar Laravel da Symfony suna tsara kodansu (interfaces da abstract base classes a ko'ina), yin su fada muhimmanci domin duka tsara kodanku kyau kuma fahimta frameworks da kake gina a sama.